@parity/product-deploy 0.7.28-rc.0

package/dist/chunk-QMYW3D6E.js

@@ -0,0 +1,316 @@
+// src/pool.ts
+import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
+import { DEV_PHRASE, entropyToMiniSecret, mnemonicToEntropy } from "@polkadot-labs/hdkd-helpers";
+import { createClient, Enum } from "polkadot-api";
+import { getPolkadotSigner } from "polkadot-api/signer";
+import { getWsProvider } from "polkadot-api/ws";
+import { Keyring } from "@polkadot/keyring";
+import { cryptoWaitReady } from "@polkadot/util-crypto";
+var PAS_DECIMALS_DIVISOR = 1e10;
+function formatPasBalance(plancks) {
+  return (Number(plancks) / PAS_DECIMALS_DIVISOR).toFixed(4);
+}
+var DEPLOY_PATH_PREFIX = "//deploy";
+var TOPUP_TRANSACTIONS = 1e3;
+var TOPUP_BYTES = 100000000n;
+var WS_HEARTBEAT_TIMEOUT_MS = 3e5;
+var AUTHORIZATION_EXTENSION_BLOCKS = 2e6;
+function derivePoolAccounts(poolSize = 10, mnemonic = DEV_PHRASE) {
+  const entropy = mnemonicToEntropy(mnemonic);
+  const miniSecret = entropyToMiniSecret(entropy);
+  const derive = sr25519CreateDerive(miniSecret);
+  const keyring = new Keyring({ type: "sr25519" });
+  const accounts = [];
+  for (let i = 0; i < poolSize; i++) {
+    const path = `${DEPLOY_PATH_PREFIX}/${i}`;
+    const keyPair = derive(path);
+    const signer = getPolkadotSigner(keyPair.publicKey, "Sr25519", keyPair.sign);
+    const address = keyring.encodeAddress(keyPair.publicKey);
+    accounts.push({ index: i, path, publicKey: keyPair.publicKey, signer, address });
+  }
+  return accounts;
+}
+function isAuthorizationSufficient(auth, currentBlock, check = {}) {
+  if (auth === void 0) return false;
+  if (Number(auth.expiration ?? 0) <= currentBlock) return false;
+  if (check.bulletinAuthorizeV2 && check.needs) {
+    const txsRemaining = BigInt(auth.extent.transactions_allowance) - BigInt(auth.extent.transactions);
+    const bytesRemaining = BigInt(auth.extent.bytes_allowance) - BigInt(auth.extent.bytes);
+    if (txsRemaining < check.needs.txs) return false;
+    if (bytesRemaining < check.needs.bytes) return false;
+  }
+  return true;
+}
+function selectAccount(authorizations, random = Math.random, currentBlock) {
+  const eligible = authorizations.filter(
+    (a) => currentBlock === void 0 || a.expiration > currentBlock
+  );
+  if (eligible.length === 0) return null;
+  return { account: eligible[Math.floor(random() * eligible.length)], eligibleCount: eligible.length };
+}
+async function fetchPoolAuthorizations(api, accounts) {
+  const results = await Promise.all(
+    accounts.map(async (account) => {
+      try {
+        const auth = await api.query.TransactionStorage.Authorizations.getValue(
+          Enum("Account", account.address)
+        );
+        return {
+          ...account,
+          transactions: auth ? BigInt(auth.extent.transactions_allowance) - BigInt(auth.extent.transactions) : 0n,
+          bytes: auth ? BigInt(auth.extent.bytes_allowance) - BigInt(auth.extent.bytes) : 0n,
+          expiration: auth ? Number(auth.expiration) : 0
+        };
+      } catch {
+        return { ...account, transactions: 0n, bytes: 0n, expiration: 0 };
+      }
+    })
+  );
+  return results;
+}
+function computeTopUpTarget(current, needs) {
+  const minTxs = needs.txs + BigInt(TOPUP_TRANSACTIONS);
+  const minBytes = needs.bytes + TOPUP_BYTES;
+  if (current.transactions >= minTxs && current.bytes >= minBytes) return null;
+  return {
+    transactions: current.transactions > minTxs ? current.transactions : minTxs,
+    bytes: current.bytes > minBytes ? current.bytes : minBytes
+  };
+}
+function classifyAliceTxError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+  if (/\bstale\b/.test(lower)) return "retry";
+  if (/"type"\s*:\s*"future"|\binvalid::future\b/.test(lower)) return "retry";
+  if (lower.includes("websocket") || lower.includes("connection") || lower.includes("socket closed") || lower.includes("disconnect")) return "retry";
+  if (lower.includes("timed out") || lower.includes("timeout")) return "retry";
+  return "abort";
+}
+var ALICE_MAX_ATTEMPTS = 3;
+async function submitAliceTxWithRetry(buildTx, aliceSigner, label) {
+  let lastError;
+  let attempts = 0;
+  for (let attempt = 1; attempt <= ALICE_MAX_ATTEMPTS; attempt++) {
+    attempts = attempt;
+    try {
+      const tx = buildTx();
+      const result = await tx.signAndSubmit(aliceSigner);
+      if (!result.ok) throw new Error(`${label} dispatch error`);
+      return;
+    } catch (e) {
+      lastError = e;
+      const decision = classifyAliceTxError(e);
+      if (decision === "abort" || attempt === ALICE_MAX_ATTEMPTS) break;
+      console.log(`   ${label}: attempt ${attempt}/${ALICE_MAX_ATTEMPTS} failed (${String(e.message ?? e).slice(0, 80)}), retrying...`);
+    }
+  }
+  const msg = lastError instanceof Error ? lastError.message : String(lastError);
+  const plural = attempts === 1 ? "attempt" : "attempts";
+  throw new Error(`${label} failed after ${attempts} ${plural}: ${msg}`);
+}
+function isTestnetSpecName(specName) {
+  if (!specName) return false;
+  const s = specName.toLowerCase();
+  if (s.includes("paseo")) return true;
+  if (/\b(westend|rococo)\b/.test(s)) return true;
+  if (/\b(testnet|devnet)\b/.test(s)) return true;
+  if (/-test$|-testnet$|-dev$/.test(s)) return true;
+  return false;
+}
+var _testnetDetectionCache = null;
+async function detectTestnet(api) {
+  if (_testnetDetectionCache !== null) return _testnetDetectionCache;
+  try {
+    const version = await api.constants.System.Version();
+    const raw = version?.spec_name ?? version?.specName;
+    const specName = typeof raw === "string" ? raw : raw?.asText?.() ?? String(raw ?? "");
+    _testnetDetectionCache = isTestnetSpecName(specName);
+  } catch {
+    _testnetDetectionCache = false;
+  }
+  return _testnetDetectionCache;
+}
+function _resetTestnetCacheForTests() {
+  _testnetDetectionCache = null;
+}
+function aliceKeyring() {
+  const keyring = new Keyring({ type: "sr25519" });
+  const alice = keyring.addFromUri("//Alice");
+  const signer = getPolkadotSigner(alice.publicKey, "Sr25519", (data) => alice.sign(data));
+  return { alice, signer };
+}
+var U32_MAX = 0xFFFFFFFFn;
+function clampU32(n, name) {
+  if (n < 0n) throw new Error(`${name} must be non-negative`);
+  if (n > U32_MAX) throw new Error(`${name} (${n}) exceeds u32 max \u2014 split the deploy into smaller batches`);
+  return Number(n);
+}
+async function ensureAuthorized(api, address, label, bulletinAuthorizeV2, needs) {
+  const [auth, currentBlock] = await Promise.all([
+    api.query.TransactionStorage.Authorizations.getValue(Enum("Account", address)),
+    api.query.System.Number.getValue()
+  ]);
+  if (isAuthorizationSufficient(auth, currentBlock, { needs, bulletinAuthorizeV2 })) return;
+  console.log(`   Auto-authorizing ${label ?? "account"} (${address.slice(0, 8)}...)...`);
+  const { signer } = aliceKeyring();
+  if (bulletinAuthorizeV2) {
+    await submitAliceTxWithRetry(
+      () => api.tx.TransactionStorage.authorize_account({
+        who: address,
+        transactions: clampU32(BigInt(TOPUP_TRANSACTIONS), "transactions"),
+        bytes: TOPUP_BYTES
+      }),
+      signer,
+      `authorize_account(${label ?? "account"})`
+    );
+    console.log(`   Authorized: ${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB`);
+  } else {
+    const newExpiration = currentBlock + AUTHORIZATION_EXTENSION_BLOCKS;
+    await submitAliceTxWithRetry(
+      () => api.tx.TransactionStorage.authorize_account({
+        who: address,
+        expiration: newExpiration
+      }),
+      signer,
+      `authorize_account(${label ?? "account"})`
+    );
+    console.log(`   Authorized: expires at block ${newExpiration} (current: ${currentBlock})`);
+  }
+}
+async function topUpBy(api, address, needs, label, bulletinAuthorizeV2) {
+  const [currentAuth, currentBlock] = await Promise.all([
+    api.query.TransactionStorage.Authorizations.getValue(Enum("Account", address)),
+    api.query.System.Number.getValue()
+  ]);
+  if (isAuthorizationSufficient(currentAuth, currentBlock, { needs, bulletinAuthorizeV2 })) {
+    const expiration = Number(currentAuth.expiration);
+    if (currentAuth.extent) {
+      const fmtMB = (b) => (Number(b) / 1e6).toFixed(1);
+      const txsRemaining = BigInt(currentAuth.extent.transactions_allowance) - BigInt(currentAuth.extent.transactions);
+      const bytesRemaining = BigInt(currentAuth.extent.bytes_allowance) - BigInt(currentAuth.extent.bytes);
+      console.log(`   Pre-auth skipped for ${label ?? "account"} (${address.slice(0, 8)}...): authorized until block ${expiration}, ${txsRemaining} txs / ${fmtMB(bytesRemaining)}MB remaining.`);
+    } else {
+      console.log(`   Pre-auth skipped for ${label ?? "account"} (${address.slice(0, 8)}...): authorized until block ${expiration}.`);
+    }
+    return;
+  }
+  const { signer } = aliceKeyring();
+  if (bulletinAuthorizeV2) {
+    console.log(`   Pre-authorizing ${label ?? "account"} (${address.slice(0, 8)}...): granting ${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB...`);
+    await submitAliceTxWithRetry(
+      () => api.tx.TransactionStorage.authorize_account({
+        who: address,
+        transactions: clampU32(BigInt(TOPUP_TRANSACTIONS), "transactions"),
+        bytes: TOPUP_BYTES
+      }),
+      signer,
+      `topUpBy(${label ?? "account"})`
+    );
+    console.log(`   Pre-authorized: ${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB`);
+  } else {
+    const newExpiration = currentBlock + AUTHORIZATION_EXTENSION_BLOCKS;
+    console.log(`   Pre-authorizing ${label ?? "account"} (${address.slice(0, 8)}...): extending authorization to block ${newExpiration}...`);
+    await submitAliceTxWithRetry(
+      () => api.tx.TransactionStorage.authorize_account({
+        who: address,
+        expiration: newExpiration
+      }),
+      signer,
+      `topUpBy(${label ?? "account"})`
+    );
+    console.log(`   Pre-authorized: expires at block ${newExpiration}`);
+  }
+}
+async function bootstrapPool(bulletinRpc, poolSize = 10, mnemonic, opts = {}) {
+  console.log(`Bootstrapping ${poolSize} pool accounts on ${bulletinRpc}...
+`);
+  await cryptoWaitReady();
+  const accounts = derivePoolAccounts(poolSize, mnemonic);
+  const client = createClient(getWsProvider(
+    bulletinRpc,
+    { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS }
+  ));
+  const api = client.getUnsafeApi();
+  const keyring = new Keyring({ type: "sr25519" });
+  const alice = keyring.addFromUri("//Alice");
+  const aliceSigner = getPolkadotSigner(alice.publicKey, "Sr25519", (data) => alice.sign(data));
+  const aliceAccount = await api.query.System.Account.getValue(alice.address);
+  const aliceBalance = BigInt(aliceAccount.data.free);
+  console.log(`Alice balance: ${formatPasBalance(aliceBalance)} PAS
+`);
+  const currentBlock = await api.query.System.Number.getValue();
+  if (opts.bulletinAuthorizeV2) {
+    console.log(`Authorizing accounts with V2 (${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB)
+`);
+  } else {
+    const authExpiration = currentBlock + AUTHORIZATION_EXTENSION_BLOCKS;
+    console.log(`Authorizing accounts until block ${authExpiration} (current: ${currentBlock})
+`);
+  }
+  for (const account of accounts) {
+    console.log(`Account ${account.index}: ${account.address}`);
+    try {
+      let tx;
+      if (opts.bulletinAuthorizeV2) {
+        tx = api.tx.TransactionStorage.authorize_account({
+          who: account.address,
+          transactions: clampU32(BigInt(TOPUP_TRANSACTIONS), "transactions"),
+          bytes: TOPUP_BYTES
+        });
+      } else {
+        const authExpiration = currentBlock + AUTHORIZATION_EXTENSION_BLOCKS;
+        tx = api.tx.TransactionStorage.authorize_account({
+          who: account.address,
+          expiration: authExpiration
+        });
+      }
+      const result = await tx.signAndSubmit(aliceSigner);
+      if (!result.ok) throw new Error("dispatch failed");
+      if (opts.bulletinAuthorizeV2) {
+        console.log(`  Authorized: ${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB`);
+      } else {
+        const authExpiration = currentBlock + AUTHORIZATION_EXTENSION_BLOCKS;
+        console.log(`  Authorized: expires at block ${authExpiration}`);
+      }
+    } catch (e) {
+      console.log(`  Authorization failed: ${e.message?.slice(0, 80)}`);
+    }
+    try {
+      const transfer = api.tx.Balances.transfer_allow_death({
+        dest: Enum("Id", account.address),
+        value: 100000000000n
+        // 0.1 PAS
+      });
+      const result = await transfer.signAndSubmit(aliceSigner);
+      if (!result.ok) throw new Error("dispatch failed");
+      console.log(`  Transferred 0.1 PAS`);
+    } catch (e) {
+      console.log(`  Transfer failed: ${e.message?.slice(0, 80)}`);
+    }
+    console.log("");
+  }
+  console.log("=".repeat(60));
+  console.log("Pool Summary");
+  console.log("=".repeat(60));
+  const auths = await fetchPoolAuthorizations(api, accounts);
+  for (const a of auths) {
+    console.log(`  ${a.index}: ${a.address} | txs: ${a.transactions} | bytes: ${Number(a.bytes) / 1e6}MB`);
+  }
+  client.destroy();
+}
+
+export {
+  formatPasBalance,
+  derivePoolAccounts,
+  isAuthorizationSufficient,
+  selectAccount,
+  fetchPoolAuthorizations,
+  computeTopUpTarget,
+  classifyAliceTxError,
+  isTestnetSpecName,
+  detectTestnet,
+  _resetTestnetCacheForTests,
+  ensureAuthorized,
+  topUpBy,
+  bootstrapPool
+};

package/dist/chunk-QTZNULSH.js

@@ -0,0 +1,185 @@
+import {
+  captureWarning
+} from "./chunk-MFTODIIT.js";
+
+// src/chunk-probe.ts
+import { Twox128, Blake2128Concat, decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
+import { CID } from "multiformats/cid";
+var ChainProbeMetadataError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = "ChainProbeMetadataError";
+  }
+};
+var ChainProbeCrossValidationError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = "ChainProbeCrossValidationError";
+  }
+};
+var _enc = new TextEncoder();
+var MAX_BLOCK = 2 ** 30;
+var MAX_TX_INDEX = 512;
+var DEFAULT_BATCH_SIZE = 500;
+var _metadataChecked = false;
+var _crossValidated = false;
+var _sentryBatchCount = 0;
+function buildStorageKey(contentHashBytes) {
+  const parts = [
+    Twox128(_enc.encode("TransactionStorage")),
+    Twox128(_enc.encode("TransactionByContentHash")),
+    Blake2128Concat(contentHashBytes)
+  ];
+  const total = parts.reduce((s, p) => s + p.length, 0);
+  const key = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    key.set(p, offset);
+    offset += p.length;
+  }
+  return "0x" + Buffer.from(key).toString("hex");
+}
+function cidToContentHash(cidStr) {
+  return CID.parse(cidStr).multihash.digest;
+}
+function hexToBytes(hex) {
+  return Buffer.from(hex.replace(/^0x/, ""), "hex");
+}
+function _decodeStorageValue(hex) {
+  if (!hex || hex === "0x" || hex === "0x00") return null;
+  const bytes = hexToBytes(hex);
+  if (bytes.length < 8) return null;
+  const block = bytes.readUInt32LE(0);
+  const index = bytes.readUInt32LE(4);
+  if (block <= 0 || block >= MAX_BLOCK || index >= MAX_TX_INDEX) return null;
+  return { block, index };
+}
+async function ensureMetadataChecked(client) {
+  if (_metadataChecked) return;
+  const metaHex = await client._request("state_getMetadata", []);
+  const decoded = decAnyMetadata(hexToBytes(metaHex));
+  const unified = unifyMetadata(decoded);
+  const pallet = unified.pallets?.find((p) => p.name === "TransactionStorage");
+  if (!pallet) throw new ChainProbeMetadataError("TransactionStorage pallet not found in runtime metadata");
+  const item = pallet.storage?.items?.find((e) => e.name === "TransactionByContentHash");
+  if (!item) throw new ChainProbeMetadataError("TransactionByContentHash entry not found in TransactionStorage");
+  if (item.type?.tag !== "map") {
+    throw new ChainProbeMetadataError(
+      `TransactionByContentHash storage type is '${item.type?.tag}', expected 'map'`
+    );
+  }
+  const hasher = item.type.value?.hashers?.[0]?.tag;
+  if (hasher !== "Blake2128Concat") {
+    throw new ChainProbeMetadataError(
+      `TransactionByContentHash key hasher is '${hasher}', expected 'Blake2128Concat'. Update key construction in chunk-probe.ts.`
+    );
+  }
+  _metadataChecked = true;
+}
+async function crossValidateFirstHit(client, cid, block, index, contentHashBytes) {
+  if (_crossValidated) return;
+  _crossValidated = true;
+  try {
+    const blockBuf = Buffer.alloc(4);
+    blockBuf.writeUInt32LE(block, 0);
+    const txKey = "0x" + Buffer.from([
+      ...Twox128(_enc.encode("TransactionStorage")),
+      ...Twox128(_enc.encode("Transactions")),
+      ...Blake2128Concat(blockBuf)
+    ]).toString("hex");
+    const result = await client._request("state_queryStorageAt", [[txKey]]);
+    const hex = result[0]?.changes?.[0]?.[1];
+    if (!hex) {
+      captureWarning("chunk-probe cross-validate: Transactions[block] absent (non-fatal)", { cid, block, index });
+      return;
+    }
+    const haystack = hexToBytes(hex);
+    const needle = Buffer.from(contentHashBytes);
+    if (!haystack.includes(needle)) {
+      throw new ChainProbeCrossValidationError(
+        `Cross-validation failed: content hash for CID ${cid} not found in Transactions[${block}]. Key construction may be wrong. Run tools/chain-probe-key-probe.mjs to diagnose.`
+      );
+    }
+  } catch (e) {
+    if (e instanceof ChainProbeCrossValidationError) throw e;
+    captureWarning("chunk-probe cross-validate RPC error (non-fatal)", { cid, error: String(e).slice(0, 200) });
+  }
+}
+async function probeChunks(cids, options) {
+  if (cids.length === 0) return [];
+  const { client, batchSize = DEFAULT_BATCH_SIZE, atFinalized } = options;
+  try {
+    await ensureMetadataChecked(client);
+  } catch (e) {
+    if (e instanceof ChainProbeMetadataError) throw e;
+    return cids.map((cid) => ({ cid, present: null, failureReason: "metadata_error" }));
+  }
+  let atHash;
+  if (atFinalized) {
+    try {
+      atHash = await client._request("chain_getFinalizedHead", []);
+    } catch (e) {
+      captureWarning("chunk-probe: chain_getFinalizedHead failed, probing best-chain", { error: String(e).slice(0, 200) });
+    }
+  }
+  const results = new Array(cids.length);
+  for (let start = 0; start < cids.length; start += batchSize) {
+    const batchCids = cids.slice(start, start + batchSize);
+    const batchDigests = batchCids.map(cidToContentHash);
+    const batchKeys = batchDigests.map(buildStorageKey);
+    let changes;
+    try {
+      const rpcResult = await client._request("state_queryStorageAt", atHash ? [batchKeys, atHash] : [batchKeys]);
+      changes = rpcResult[0]?.changes ?? [];
+    } catch {
+      for (let i = 0; i < batchCids.length; i++) {
+        results[start + i] = { cid: batchCids[i], present: null, failureReason: "rpc_error" };
+      }
+      continue;
+    }
+    const keyToValue = new Map(changes);
+    for (let i = 0; i < batchCids.length; i++) {
+      const cid = batchCids[i];
+      const key = batchKeys[i];
+      const rawValue = keyToValue.get(key) ?? null;
+      if (!rawValue) {
+        results[start + i] = { cid, present: false };
+        continue;
+      }
+      const decoded = _decodeStorageValue(rawValue);
+      if (!decoded) {
+        if (_sentryBatchCount < 3) {
+          captureWarning("chunk-probe decode failed (out-of-range or short value)", {
+            cid,
+            raw_hex: rawValue.slice(0, 64)
+          });
+        }
+        results[start + i] = { cid, present: null, failureReason: "decode_error" };
+        continue;
+      }
+      results[start + i] = { cid, present: true, block: decoded.block, index: decoded.index };
+      if (!_crossValidated) {
+        await crossValidateFirstHit(client, cid, decoded.block, decoded.index, batchDigests[i]);
+      }
+    }
+    if (_sentryBatchCount < 3) _sentryBatchCount++;
+  }
+  return results;
+}
+function _resetProbeSession() {
+  _metadataChecked = false;
+  _crossValidated = false;
+  _sentryBatchCount = 0;
+}
+function _bypassMetadataCheckForTest() {
+  _metadataChecked = true;
+}
+
+export {
+  ChainProbeMetadataError,
+  ChainProbeCrossValidationError,
+  _decodeStorageValue,
+  probeChunks,
+  _resetProbeSession,
+  _bypassMetadataCheckForTest
+};

package/dist/chunk-RI3ZLNPN.js

@@ -0,0 +1,71 @@
+// src/manifest/byte-budget.ts
+var DEFAULT_TEXT_RECORD_BUDGET_BYTES = 1024;
+var PLACEHOLDER_CID = "bafkreigh2akiscaildc7zh3vznzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+function getTextRecordBudgetBytes() {
+  const raw = process.env.BULLETIN_TEXT_BUDGET;
+  if (raw === void 0 || raw === "") return DEFAULT_TEXT_RECORD_BUDGET_BYTES;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return DEFAULT_TEXT_RECORD_BUDGET_BYTES;
+  return parsed;
+}
+function assertWithinBudget(key, serialized, budget) {
+  const bytes = Buffer.byteLength(serialized, "utf8");
+  return { ok: bytes <= budget, key, bytes, budget };
+}
+function pessimisticSizePreflight(config, budget = getTextRecordBudgetBytes()) {
+  const checks = [];
+  const placeholderRoot = {
+    $v: 1,
+    displayName: config.displayName,
+    description: config.description,
+    icon: { cid: PLACEHOLDER_CID, format: config.icon.format }
+  };
+  checks.push(
+    assertWithinBudget(
+      `${config.domain}#manifest`,
+      JSON.stringify(placeholderRoot),
+      budget
+    )
+  );
+  for (const exec of config.executables) {
+    const placeholder = composePlaceholderExecutable(exec);
+    checks.push(
+      assertWithinBudget(
+        `${exec.kind}.${config.domain}#executable`,
+        JSON.stringify(placeholder),
+        budget
+      )
+    );
+  }
+  return { ok: checks.every((c) => c.ok), budget, checks };
+}
+function composePlaceholderExecutable(exec) {
+  if (exec.kind === "app") {
+    return { $v: 1, kind: "app", appVersion: exec.appVersion };
+  }
+  if (exec.kind === "widget") {
+    return {
+      $v: 1,
+      kind: "widget",
+      appVersion: exec.appVersion,
+      dimensions: exec.dimensions,
+      ...exec.description !== void 0 ? { description: exec.description } : {}
+    };
+  }
+  return {
+    $v: 1,
+    kind: "worker",
+    appVersion: exec.appVersion,
+    entrypoint: exec.entrypoint,
+    includes: exec.includes
+  };
+}
+
+export {
+  DEFAULT_TEXT_RECORD_BUDGET_BYTES,
+  PLACEHOLDER_CID,
+  getTextRecordBudgetBytes,
+  assertWithinBudget,
+  pessimisticSizePreflight
+};

package/dist/chunk-S7EM5VMW.js

@@ -0,0 +1,108 @@
+// src/manifest.ts
+var MANIFEST_VERSION = 3;
+var MANIFEST_DIR = ".bulletin-deploy";
+var MANIFEST_FILENAME = "manifest.json";
+var MANIFEST_PATH = `${MANIFEST_DIR}/${MANIFEST_FILENAME}`;
+var STABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "wasm",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "svg",
+  "ico",
+  "mp3",
+  "mp4",
+  "webm",
+  "ogg",
+  "pdf"
+]);
+var CONTENT_HASH_RE = /[-.](?:[a-f0-9]{6,16}|[A-Za-z0-9]{6,16})\.[a-zA-Z0-9]+$/;
+function isVolatilePath(p) {
+  return p.startsWith(`${MANIFEST_DIR}/`) || p === MANIFEST_DIR;
+}
+function classifyFileHeuristic(filePath, framework) {
+  if (isVolatilePath(filePath)) return "volatile";
+  if (CONTENT_HASH_RE.test(filePath)) return "stable";
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (ext && STABLE_EXTENSIONS.has(ext)) return "stable";
+  if (framework === "next") {
+    if (filePath.startsWith("_next/static/")) return "stable";
+  }
+  if (framework === "vite") {
+    if (filePath.startsWith("assets/") && CONTENT_HASH_RE.test(filePath)) return "stable";
+  }
+  return "volatile";
+}
+function classifyFile(filePath, ctx = {}) {
+  if (isVolatilePath(filePath)) return "volatile";
+  const prev = ctx.prevManifest;
+  if (prev && ctx.fileCid !== void 0) {
+    const entry = prev.files[filePath];
+    if (entry && entry.cid === ctx.fileCid) return "stable";
+    return "volatile";
+  }
+  return classifyFileHeuristic(filePath, ctx.framework ?? null);
+}
+function parseManifest(raw) {
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch (e) {
+    return { ok: false, error: `manifest JSON parse error: ${e.message}` };
+  }
+  if (!obj || typeof obj !== "object") return { ok: false, error: "manifest is not an object" };
+  if (typeof obj.version !== "number") return { ok: false, error: "manifest.version missing or not number" };
+  if (!(obj.previous_contenthash === null || typeof obj.previous_contenthash === "string")) {
+    return { ok: false, error: "manifest.previous_contenthash must be string|null" };
+  }
+  if (typeof obj.deployed_at !== "string") return { ok: false, error: "manifest.deployed_at missing" };
+  if (!obj.files || typeof obj.files !== "object") return { ok: false, error: "manifest.files missing" };
+  if (!Array.isArray(obj.stableBlockOrder)) return { ok: false, error: "manifest.stableBlockOrder missing" };
+  if (!obj.chunks || typeof obj.chunks !== "object") return { ok: false, error: "manifest.chunks missing" };
+  const chunks = {};
+  for (const [cid, raw2] of Object.entries(obj.chunks)) {
+    const r = raw2;
+    if (r && typeof r === "object") {
+      const size = typeof r.size === "number" ? r.size : 0;
+      const deployedAt = typeof r.deployed_at === "string" ? r.deployed_at : "1970-01-01T00:00:00.000Z";
+      chunks[cid] = {
+        size,
+        deployed_at: deployedAt,
+        ...typeof r.block === "number" ? { block: r.block } : {},
+        ...typeof r.index === "number" ? { index: r.index } : {}
+      };
+    } else {
+      chunks[cid] = { size: 0, deployed_at: "1970-01-01T00:00:00.000Z" };
+    }
+  }
+  const manifest = {
+    version: obj.version,
+    previous_contenthash: obj.previous_contenthash,
+    deployed_at: obj.deployed_at,
+    framework: typeof obj.framework === "string" ? obj.framework : null,
+    files: obj.files,
+    stableBlockOrder: obj.stableBlockOrder,
+    blocks: Array.isArray(obj.blocks) ? obj.blocks : [],
+    chunks
+  };
+  return { ok: true, manifest };
+}
+
+export {
+  MANIFEST_VERSION,
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  isVolatilePath,
+  classifyFileHeuristic,
+  classifyFile,
+  parseManifest
+};