@parity/product-deploy 0.7.28-rc.0

package/dist/chunk-T7EEVWNU.js

@@ -0,0 +1,32 @@
+// src/personhood/constants.ts
+import { Binary } from "polkadot-api";
+var DOTNS_CONTEXT_HEX = "0x646f746e73000000000000000000000000000000000000000000000000000000";
+var DOTNS_CONTEXT_BYTES = Binary.fromHex(DOTNS_CONTEXT_HEX);
+var PGAS_ASSET_ID = 2e9;
+var PGAS_ASSET_LOCATION = {
+  parents: 0,
+  interior: {
+    type: "X2",
+    value: [
+      { type: "PalletInstance", value: 50 },
+      { type: "GeneralIndex", value: BigInt(PGAS_ASSET_ID) }
+    ]
+  }
+};
+var PROOF_BYTES = 788;
+var BANDERSNATCH_SIGNATURE_BYTES = 96;
+var PEOPLE_MEMBER_IDENTIFIER_HEX = "0x70656f706c652020202020202020202020202020202020202020202020202020";
+var MEMBER_ENTROPY_KEY = new TextEncoder().encode("candidate");
+var PAID_PROOF_TAG = new TextEncoder().encode("alias-accounts:paid");
+
+export {
+  DOTNS_CONTEXT_HEX,
+  DOTNS_CONTEXT_BYTES,
+  PGAS_ASSET_ID,
+  PGAS_ASSET_LOCATION,
+  PROOF_BYTES,
+  BANDERSNATCH_SIGNATURE_BYTES,
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  MEMBER_ENTROPY_KEY,
+  PAID_PROOF_TAG
+};

package/dist/chunk-UPWEOGLQ.js

@@ -0,0 +1,37 @@
+// src/personhood/hashing.ts
+import { blake2b } from "@noble/hashes/blake2b";
+import { Binary } from "polkadot-api";
+var hexToBytes = (hex) => {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+};
+function blake2b256(data) {
+  let payload;
+  if (typeof data === "string") {
+    if (data.startsWith("0x")) {
+      payload = hexToBytes(data);
+    } else {
+      payload = Binary.fromText(data);
+    }
+  } else {
+    if (data[0] === 48 && data[1] === 120) {
+      const hexString = new TextDecoder().decode(data);
+      payload = hexToBytes(hexString);
+    } else {
+      payload = data;
+    }
+  }
+  return blake2b(payload, { dkLen: 32 });
+}
+function blake2b256Keyed(data, key) {
+  return blake2b(data, { key, dkLen: 32 });
+}
+
+export {
+  blake2b256,
+  blake2b256Keyed
+};

package/dist/chunk-ZOC4GITL.js

@@ -0,0 +1,13 @@
+// src/errors.ts
+var NonRetryableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NonRetryableError";
+  }
+};
+var EXIT_CODE_NO_RETRY = 78;
+
+export {
+  NonRetryableError,
+  EXIT_CODE_NO_RETRY
+};

package/dist/chunk-ZYVGHDMU.js

@@ -0,0 +1,117 @@
+// src/personhood/encoding.ts
+import { blake2b } from "@noble/hashes/blake2b";
+var concatBytes = (...arrays) => {
+  let total = 0;
+  for (const a of arrays) total += a.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+};
+var compactEncode = (n) => {
+  if (n < 0) throw new Error("compactEncode: negative");
+  if (n < 64) return new Uint8Array([n << 2]);
+  if (n < 16384) {
+    const v = n << 2 | 1;
+    return new Uint8Array([v & 255, v >> 8 & 255]);
+  }
+  if (n < 1073741824) {
+    const v = n << 2 | 2;
+    return new Uint8Array([
+      v & 255,
+      v >> 8 & 255,
+      v >> 16 & 255,
+      v >>> 24 & 255
+    ]);
+  }
+  throw new Error("compactEncode: value too large for inline path");
+};
+var blake2_256 = (data) => blake2b(data, { dkLen: 32 });
+var buildImplicationMessage = (callBytes, extensions, excludeIdentifiers) => {
+  const exclude = typeof excludeIdentifiers === "string" ? /* @__PURE__ */ new Set([excludeIdentifiers]) : excludeIdentifiers;
+  const restExplicit = [];
+  const restImplicit = [];
+  for (const id of extensions.order) {
+    if (exclude.has(id)) continue;
+    const ext = extensions.byIdentifier[id];
+    if (!ext) throw new Error(`buildImplication: missing extension '${id}'`);
+    restExplicit.push(ext.value);
+    restImplicit.push(ext.additionalSigned);
+  }
+  const implication = concatBytes(
+    new Uint8Array([0]),
+    callBytes,
+    ...restExplicit,
+    ...restImplicit
+  );
+  return blake2_256(implication);
+};
+var buildV5GeneralExtrinsic = (callBytes, extensions) => {
+  const explicit = extensions.order.map((id) => {
+    const ext = extensions.byIdentifier[id];
+    if (!ext) throw new Error(`buildV5General: missing extension '${id}'`);
+    return ext.value;
+  });
+  const body = concatBytes(
+    new Uint8Array([69]),
+    new Uint8Array([0]),
+    ...explicit,
+    callBytes
+  );
+  return concatBytes(compactEncode(body.length), body);
+};
+var toHex = (bytes) => {
+  let hex = "0x";
+  for (const b of bytes) {
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return hex;
+};
+var hexToBytes = (hex) => {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+};
+var bytesToHex = (b) => "0x" + Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+var readExtensionOrder = async (metadata) => {
+  const { decAnyMetadata, unifyMetadata } = await import("@polkadot-api/substrate-bindings");
+  const meta = unifyMetadata(decAnyMetadata(metadata));
+  const raw = meta.extrinsic.signedExtensions;
+  let list = null;
+  if (Array.isArray(raw) && raw.length > 0 && Array.isArray(raw[0])) {
+    list = raw[0];
+  } else if (Array.isArray(raw)) {
+    list = raw;
+  } else if (typeof raw === "object" && raw !== null && Array.isArray(raw[0])) {
+    list = raw[0];
+  }
+  if (!list || list.length === 0) {
+    throw new Error("metadata has no signed extensions");
+  }
+  return list.map((entry) => entry.identifier);
+};
+var encodeMembers = (members) => {
+  for (const m of members) {
+    if (m.length !== 32) throw new Error("member key must be 32 bytes");
+  }
+  return concatBytes(compactEncode(members.length), ...members);
+};
+
+export {
+  concatBytes,
+  compactEncode,
+  blake2_256,
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  toHex,
+  hexToBytes,
+  bytesToHex,
+  readExtensionOrder,
+  encodeMembers
+};

package/dist/chunk-probe.d.ts

@@ -0,0 +1,37 @@
+type ChunkProbeFailureReason = "rpc_error" | "decode_error" | "metadata_error";
+type ChunkProbeResult = {
+    cid: string;
+    present: false;
+} | {
+    cid: string;
+    present: true;
+    block: number;
+    index: number;
+} | {
+    cid: string;
+    present: null;
+    failureReason: ChunkProbeFailureReason;
+};
+interface ChainProbeOptions {
+    client: any;
+    batchSize?: number;
+    atFinalized?: boolean;
+}
+declare class ChainProbeMetadataError extends Error {
+    constructor(msg: string);
+}
+declare class ChainProbeCrossValidationError extends Error {
+    constructor(msg: string);
+}
+/** Exported for unit testing. */
+declare function _decodeStorageValue(hex: string | null | undefined): {
+    block: number;
+    index: number;
+} | null;
+declare function probeChunks(cids: string[], options: ChainProbeOptions): Promise<ChunkProbeResult[]>;
+/** Reset session-level caches. Used in tests only. */
+declare function _resetProbeSession(): void;
+/** Pre-set metadataChecked so tests don't need a real metadata RPC mock. Used in tests only. */
+declare function _bypassMetadataCheckForTest(): void;
+
+export { ChainProbeCrossValidationError, ChainProbeMetadataError, type ChainProbeOptions, type ChunkProbeFailureReason, type ChunkProbeResult, _bypassMetadataCheckForTest, _decodeStorageValue, _resetProbeSession, probeChunks };

package/dist/chunk-probe.js

@@ -0,0 +1,18 @@
+import {
+  ChainProbeCrossValidationError,
+  ChainProbeMetadataError,
+  _bypassMetadataCheckForTest,
+  _decodeStorageValue,
+  _resetProbeSession,
+  probeChunks
+} from "./chunk-QTZNULSH.js";
+import "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+export {
+  ChainProbeCrossValidationError,
+  ChainProbeMetadataError,
+  _bypassMetadataCheckForTest,
+  _decodeStorageValue,
+  _resetProbeSession,
+  probeChunks
+};

package/dist/chunker.d.ts

@@ -0,0 +1,8 @@
+declare const CHUNK_SIZE_TARGET: number;
+declare const CHUNK_SIZE_MAX: number;
+interface SectionFile {
+    blocks: Uint8Array[];
+}
+declare function packSection(files: SectionFile[]): Uint8Array[];
+
+export { CHUNK_SIZE_MAX, CHUNK_SIZE_TARGET, type SectionFile, packSection };

package/dist/chunker.js

@@ -0,0 +1,10 @@
+import {
+  CHUNK_SIZE_MAX,
+  CHUNK_SIZE_TARGET,
+  packSection
+} from "./chunk-C2TS5MER.js";
+export {
+  CHUNK_SIZE_MAX,
+  CHUNK_SIZE_TARGET,
+  packSection
+};

package/dist/deploy.d.ts

@@ -0,0 +1,299 @@
+import { CID } from 'multiformats/cid';
+import { ManifestFileEntry } from './manifest.js';
+import { PopSelfServeConfig } from './environments.js';
+import { PolkadotSigner } from 'polkadot-api';
+export { EXIT_CODE_NO_RETRY, NonRetryableError } from './errors.js';
+
+interface DeployResult {
+    domainName: string;
+    fullDomain: string;
+    cid: string;
+    ipfsCid?: string;
+}
+type DeployContent = string | Uint8Array | Uint8Array[];
+
+declare function friendlyChainError(msg: string): string;
+interface ProviderResult {
+    client: any;
+    unsafeApi: any;
+    signer: PolkadotSigner;
+    ss58: string;
+}
+interface ExistingProvider {
+    client?: any;
+    unsafeApi?: any;
+    signer?: PolkadotSigner;
+    ss58?: string;
+    reconnect?: () => Promise<ProviderResult>;
+    fetchNonce?: (rpc: string | string[], ss58: string) => Promise<number>;
+    skipCids?: Set<string>;
+    probeFailedCids?: Set<string>;
+    gateway?: string;
+    bulletinAuthorizeV2?: boolean;
+    /**
+     * CIDs the caller vouches are already on-chain. Chunks matching these CIDs
+     * are skipped without any re-probe (unlike `skipCids` which re-probes before
+     * skipping). Invariant: only pass CIDs verified or uploaded within the same
+     * chain connection during the current deploy — they are trusted to still be
+     * present (eviction within a single deploy session is negligible).
+     */
+    trustedCids?: Set<string>;
+    /**
+     * When true, skip the DAG-PB root build + setRoot tx at the end of
+     * storeChunkedContent. Phase A in the V2 path passes this because the
+     * caller (storeDirectoryV2) never uses the Phase A root CID — Phase B
+     * computes and stores the real root, which becomes the contenthash.
+     */
+    skipRootStore?: boolean;
+}
+interface ChainReceipt {
+    txHash: string;
+    blockHash: string;
+    blockNumber: number;
+}
+interface StoredChunk {
+    cid: CID;
+    len: number;
+    viaFallback?: boolean;
+    receipt?: ChainReceipt;
+}
+declare const DEFAULT_BULLETIN_RPC = "wss://paseo-bulletin-rpc.polkadot.io";
+declare const DEFAULT_POOL_SIZE = 10;
+declare function setWsHaltCallback(cb: (() => void) | null): void;
+declare const CHUNK_MORTALITY_PERIOD: number;
+declare function retryBudgetExhausted(history: number[], maxEvents: number, windowMs: number, now?: number): boolean;
+declare function isConnectionError(error: any): boolean;
+declare function deriveRootSigner(mnemonic: string, path?: string): {
+    signer: PolkadotSigner;
+    ss58: string;
+};
+declare function createCID(data: Uint8Array, codec?: number, hashCode?: number): CID;
+declare function encodeContenthash(cidString: string): string;
+declare const ENCRYPT_MAGIC: Uint8Array<ArrayBuffer>;
+declare const ENCRYPT_SALT_LEN = 16;
+declare const ENCRYPT_NONCE_LEN = 12;
+declare const ENCRYPT_TAG_LEN = 16;
+declare const ENCRYPT_KEY_LEN = 32;
+declare const ENCRYPT_PBKDF2_ITERATIONS = 100000;
+declare function encryptContent(data: Uint8Array, password: string): Promise<Uint8Array>;
+declare function storeFile(contentBytes: Uint8Array, { client: existingClient, unsafeApi: existingApi, signer: existingSigner }?: ExistingProvider): Promise<string>;
+/**
+ * Pre-compute dense nonces for chunks that need submission.
+ * Chunks where stored[i] !== null are already on chain (skipped via skipCids or
+ * prior reconnect logic) and consume zero nonce slots.
+ * Exported under a test-only alias so unit tests can verify the dense property
+ * without touching the real chain.
+ */
+declare function assignDenseNonces(stored: (StoredChunk | null)[], startNonce: number): Map<number, number>;
+declare const __assignDenseNoncesForTest: typeof assignDenseNonces;
+declare function storeChunkedContent(chunks: Uint8Array[], { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride, skipCids, probeFailedCids, gateway: providerGateway, bulletinAuthorizeV2, trustedCids, skipRootStore }?: ExistingProvider): Promise<{
+    storageCid: string;
+    tier2Verified: number;
+    tier2Inconclusive: number;
+    tier2Fallback: number;
+    liveProvider: ExistingProvider;
+    skipProbeResults: Map<string, true | false | null>;
+    rootSkipped: boolean;
+}>;
+declare function chunk(data: Uint8Array, size?: number): Uint8Array[];
+declare function hasIPFS(): boolean;
+declare function merkleize(directoryPath: string, outputCarPath: string): Promise<{
+    carPath: string;
+    cid: string;
+}>;
+declare function computeStorageCid(chunks: Uint8Array[]): string;
+interface StoreDirectoryOptions {
+    provider?: ExistingProvider;
+    password?: string;
+    jsMerkle?: boolean;
+    /**
+     * Fires exactly once, right after the CAR has been merkleized + encrypted
+     * and the final storage CID is known, but BEFORE the chunk upload to
+     * Bulletin starts. Use to kick off parallel side-effects (e.g. the
+     * gh-pages mirror) that can run concurrently with the slow upload. The
+     * returned promise is awaited at the end of the deploy; errors are passed
+     * through to the caller so they can decide fatal / non-fatal policy.
+     */
+    onCarReady?: (carBytes: Uint8Array, storageCid: string) => Promise<void> | void;
+    /**
+     * v2 incremental upload: contenthash from the previous deploy of this
+     * domain (the IPFS CID, not the e3-prefixed bytes). The new flow fetches
+     * this CID's embedded manifest via the gateway, classifies files,
+     * probes chunks for presence, and skips re-uploading any chunk already
+     * stored on chain. Pass null (or omit) for first-deploy behaviour.
+     * Encrypted deploys (password set) bypass the incremental path because
+     * encryption breaks chunk-level dedup.
+     */
+    previousContenthash?: string | null;
+    /** Override gateway URL for manifest fetch + chunk probes. */
+    gateway?: string;
+    /** Skip the 500 MiB abort guard and allow oversized deploys. */
+    allowLargeDeploy?: boolean;
+    /**
+     * Pin the `deployedAt` timestamp for byte-identical rebuilds.
+     * Values: "commit" (git committer date), "epoch:<N>" (Unix epoch seconds),
+     * or any ISO 8601 string. Omit for a live wall-clock timestamp.
+     */
+    reproducibleSource?: string;
+    /**
+     * DotNS domain label being deployed (without the `.dot` suffix, e.g. `"myapp"`).
+     * When provided, `fetchPreviousManifest` also tries the GitHub Pages mirror
+     * before falling through to the IPFS gateway.
+     */
+    domain?: string;
+    /**
+     * Opt-in: write the pre-upload CAR file to disk after merkleization.
+     * - `true` → write to `<buildDir>.bulletin.car` (default path).
+     * - `string` → write to that explicit path.
+     * - omitted / `false` → no file written (default).
+     * Also honoured when `BULLETIN_DEPLOY_DUMP_CAR` env var is set (back-compat).
+     */
+    dumpCar?: string | boolean;
+}
+declare function storeDirectory(directoryPath: string, providerOrOptions?: ExistingProvider | StoreDirectoryOptions, password?: string, jsMerkle?: boolean): Promise<{
+    storageCid: string;
+    ipfsCid: string;
+    carBytes: Uint8Array;
+}>;
+declare function buildFilesMap(buildDir: string, fileCids?: Map<string, string>): Record<string, ManifestFileEntry>;
+declare function detectFramework(directoryPath: string): string | null;
+type SizeDecision = {
+    kind: "ok";
+} | {
+    kind: "warn";
+    message: string;
+} | {
+    kind: "abort";
+    message: string;
+};
+declare function checkDeploySize(carBytes: number, opts: {
+    allowLargeDeploy?: boolean;
+}): SizeDecision;
+declare function resolveReproducibleTimestamp(source: string): string;
+declare function applyManifestFetchAttributes(fetched: {
+    source: string;
+    attempts?: number;
+    bytesDownloaded?: number;
+}): void;
+declare function storeDirectoryV2(directoryPath: string, opts?: StoreDirectoryOptions): Promise<{
+    storageCid: string;
+    ipfsCid: string;
+    carBytes: Uint8Array;
+}>;
+interface DeployOptions {
+    mnemonic?: string;
+    /** Optional derivation path applied to the mnemonic (e.g. "//deploy/3"). Defaults to "" (root key). */
+    derivationPath?: string;
+    /** Pre-built signer — skips mnemonic derivation. Use for QR/mobile signing. */
+    signer?: PolkadotSigner;
+    /** SS58 address for the signer (required when signer is provided). */
+    signerAddress?: string;
+    rpc?: string;
+    poolSize?: number;
+    password?: string;
+    /** Use pure-JS merkleization instead of Kubo CLI. Required for WebContainer environments. */
+    jsMerkle?: boolean;
+    /**
+     * Free-form label attached to the deploy span as `deploy.tag`. Used to separate
+     * test/benchmark/canary runs from real-user traffic in Sentry dashboards
+     * (e.g. "e2e-ci-pr", "load-test-a"). Falls back to DEPLOY_TAG env var.
+     */
+    tag?: string;
+    /** Custom telemetry attributes, merged into the deploy span. Overrides auto-detected values. */
+    attributes?: Record<string, string>;
+    /**
+     * Opt-in: after a successful deploy, push the CAR to the current repo's
+     * `gh-pages` branch under `bulletin/<domain>.dot.car` so hosts can fetch it
+     * via `https://<owner>.github.io/<repo>/bulletin/<domain>.dot.car` as a
+     * fast-path cache. Non-fatal on failure. See docs/… for the discoverability
+     * caveat.
+     */
+    ghPagesMirror?: boolean;
+    /** Skip the 500 MiB abort guard and allow oversized deploys. */
+    allowLargeDeploy?: boolean;
+    /**
+     * Filesystem path to a pre-built `.car` file. When set, skips directory
+     * scanning and merkleization; the CAR bytes are read from disk, the root
+     * CID is parsed from the CAR header, and the file is uploaded directly.
+     * The positional `<build-dir>` argument is not required when this is set.
+     */
+    inputCar?: string;
+    /**
+     * Pin the `deployedAt` timestamp for byte-identical rebuilds.
+     * Values: "commit" (git committer date), "epoch:<N>" (Unix epoch seconds),
+     * or any ISO 8601 string. Omit for a live wall-clock timestamp.
+     */
+    reproducibleSource?: string;
+    /**
+     * Environment id from environments.json (e.g. "paseo-next-v2", "paseo-review").
+     * Drives both the bulletin RPC and the asset-hub RPC. Defaults to
+     * DEFAULT_ENV_ID. `--rpc` / BULLETIN_RPC still override the bulletin endpoint
+     * within the chosen env.
+     */
+    env?: string;
+    /**
+     * Pre-resolved bulletin endpoints (escape hatch for tests / library callers
+     * that want to skip environments.json loading). When provided, the loader
+     * is not called and `env` is ignored.
+     */
+    bulletinEndpoints?: string[];
+    /** Pre-resolved asset-hub endpoints. Same escape-hatch semantics. */
+    assetHubEndpoints?: string[];
+    /**
+     * Opt-in: write the pre-upload CAR file to disk after merkleization.
+     * - `true` → write to `<buildDir>.bulletin.car` (default path).
+     * - `string` → write to that explicit path.
+     * - omitted / `false` → no file written (default).
+     * Also honoured when `BULLETIN_DEPLOY_DUMP_CAR` env var is set (back-compat).
+     * CLI: --dump-car[=<path>]
+     */
+    dumpCar?: string | boolean;
+    /**
+     * After a successful deploy, list the label in the on-chain Publisher
+     * registry. Silently skipped on envs that do not have a Publisher contract.
+     */
+    publish?: boolean;
+    /**
+     * When true, a publish failure after a successful deploy fails the run.
+     * Default (false): warning is logged, deploy still exits 0 — the bytes
+     * landed on Bulletin and the contenthash is on chain, the registry is a
+     * discovery courtesy.
+     */
+    failOnPublishError?: boolean;
+}
+declare function resolveDotnsConnectOptions(options: Pick<DeployOptions, "mnemonic" | "derivationPath" | "signer" | "signerAddress">, assetHubEndpoints?: string[], autoAccountMapping?: boolean, contracts?: Record<string, string>, nativeToEthRatio?: bigint, environmentId?: string, popSelfServe?: PopSelfServeConfig | null, registerStorageDeposit?: bigint): {
+    signer?: PolkadotSigner;
+    signerAddress?: string;
+    mnemonic?: string;
+    derivationPath?: string;
+    assetHubEndpoints?: string[];
+    autoAccountMapping?: boolean;
+    contracts?: Record<string, string>;
+    nativeToEthRatio?: bigint;
+    environmentId?: string;
+    popSelfServe?: PopSelfServeConfig | null;
+    registerStorageDeposit?: bigint;
+};
+declare function estimateUploadBytes(content: DeployContent): Promise<number | null>;
+/**
+ * Throws NonRetryableError if a subdomain is owned by a different address
+ * than the current signer. Called in the preflight branch before chunk upload.
+ * Issue #562: preflight was only checking `owned`, not comparing `owner`.
+ */
+declare function assertSubdomainOwnerMatchesSigner(result: {
+    owned: boolean;
+    owner: string | null | undefined;
+}, signerEvmAddress: string | null | undefined, sublabel: string, parentLabel: string): void;
+declare function unpublish(domainName: string, options?: {
+    mnemonic?: string;
+    derivationPath?: string;
+    rpc?: string;
+    env?: string;
+}): Promise<{
+    domainName: string;
+    status: "unpublished" | "already-unpublished";
+    txHash?: string;
+}>;
+declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;
+
+export { CHUNK_MORTALITY_PERIOD, DEFAULT_BULLETIN_RPC, DEFAULT_POOL_SIZE, type DeployContent, type DeployOptions, type DeployResult, ENCRYPT_KEY_LEN, ENCRYPT_MAGIC, ENCRYPT_NONCE_LEN, ENCRYPT_PBKDF2_ITERATIONS, ENCRYPT_SALT_LEN, ENCRYPT_TAG_LEN, type SizeDecision, type StoreDirectoryOptions, __assignDenseNoncesForTest, applyManifestFetchAttributes, assertSubdomainOwnerMatchesSigner, buildFilesMap, checkDeploySize, chunk, computeStorageCid, createCID, deploy, deriveRootSigner, detectFramework, encodeContenthash, encryptContent, estimateUploadBytes, friendlyChainError, hasIPFS, isConnectionError, merkleize, resolveDotnsConnectOptions, resolveReproducibleTimestamp, retryBudgetExhausted, setWsHaltCallback, storeChunkedContent, storeDirectory, storeDirectoryV2, storeFile, unpublish };

package/dist/deploy.js

@@ -0,0 +1,96 @@
+import {
+  CHUNK_MORTALITY_PERIOD,
+  DEFAULT_BULLETIN_RPC,
+  DEFAULT_POOL_SIZE,
+  ENCRYPT_KEY_LEN,
+  ENCRYPT_MAGIC,
+  ENCRYPT_NONCE_LEN,
+  ENCRYPT_PBKDF2_ITERATIONS,
+  ENCRYPT_SALT_LEN,
+  ENCRYPT_TAG_LEN,
+  __assignDenseNoncesForTest,
+  applyManifestFetchAttributes,
+  assertSubdomainOwnerMatchesSigner,
+  buildFilesMap,
+  checkDeploySize,
+  chunk,
+  computeStorageCid,
+  createCID,
+  deploy,
+  deriveRootSigner,
+  detectFramework,
+  encodeContenthash,
+  encryptContent,
+  estimateUploadBytes,
+  friendlyChainError,
+  hasIPFS,
+  isConnectionError,
+  merkleize,
+  resolveDotnsConnectOptions,
+  resolveReproducibleTimestamp,
+  retryBudgetExhausted,
+  setWsHaltCallback,
+  storeChunkedContent,
+  storeDirectory,
+  storeDirectoryV2,
+  storeFile,
+  unpublish
+} from "./chunk-P6CHOMN3.js";
+import "./chunk-KHVTYIIX.js";
+import "./chunk-KOSF5FDO.js";
+import "./chunk-FZWJV5AD.js";
+import "./chunk-S7EM5VMW.js";
+import "./chunk-ADNBLFDP.js";
+import "./chunk-43HLT335.js";
+import "./chunk-QTZNULSH.js";
+import "./chunk-C2TS5MER.js";
+import "./chunk-DNXH4QTI.js";
+import "./chunk-QMYW3D6E.js";
+import "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+import "./chunk-OITUIM2E.js";
+import {
+  EXIT_CODE_NO_RETRY,
+  NonRetryableError
+} from "./chunk-ZOC4GITL.js";
+import "./chunk-HOTQDYHD.js";
+export {
+  CHUNK_MORTALITY_PERIOD,
+  DEFAULT_BULLETIN_RPC,
+  DEFAULT_POOL_SIZE,
+  ENCRYPT_KEY_LEN,
+  ENCRYPT_MAGIC,
+  ENCRYPT_NONCE_LEN,
+  ENCRYPT_PBKDF2_ITERATIONS,
+  ENCRYPT_SALT_LEN,
+  ENCRYPT_TAG_LEN,
+  EXIT_CODE_NO_RETRY,
+  NonRetryableError,
+  __assignDenseNoncesForTest,
+  applyManifestFetchAttributes,
+  assertSubdomainOwnerMatchesSigner,
+  buildFilesMap,
+  checkDeploySize,
+  chunk,
+  computeStorageCid,
+  createCID,
+  deploy,
+  deriveRootSigner,
+  detectFramework,
+  encodeContenthash,
+  encryptContent,
+  estimateUploadBytes,
+  friendlyChainError,
+  hasIPFS,
+  isConnectionError,
+  merkleize,
+  resolveDotnsConnectOptions,
+  resolveReproducibleTimestamp,
+  retryBudgetExhausted,
+  setWsHaltCallback,
+  storeChunkedContent,
+  storeDirectory,
+  storeDirectoryV2,
+  storeFile,
+  unpublish
+};