@parity/product-deploy 0.7.28-rc.0 → 0.7.28

package/assets/environments.json

@@ -8,7 +8,6 @@
       "backend": "https://polkadot-app-stg.parity.io/",
       "ipfs": "https://previewnet.substrate.dev",
       "autoAccountMapping": true,
-      "bulletinAuthorizeV2": true,
       "registerStorageDeposit": 2000000000000,
       "contracts": {
         "DOTNS_PROTOCOL_REGISTRY": "0xc07A2F24387DA27283CD87b9F24573b74C9e0c9b",
@@ -55,7 +54,6 @@
       "ipfs": "https://paseo-bulletin-next-ipfs.polkadot.io",
       "docsUrl": "https://sre.teleport.parity.io/environments/paseo-next/",
       "autoAccountMapping": true,
-      "bulletinAuthorizeV2": true,
       "nativeToEthRatio": 100000000,
       "registerStorageDeposit": 2000000000000,
       "popSelfServe": {

package/dist/bug-report.js

@@ -9,10 +9,10 @@ import {
   offerBugReport,
   scrubSecrets,
   setDeployContext
-} from "./chunk-ADNBLFDP.js";
-import "./chunk-43HLT335.js";
-import "./chunk-MFTODIIT.js";
-import "./chunk-KJH2T5TQ.js";
+} from "./chunk-THZU3FZU.js";
+import "./chunk-64KTKZ7H.js";
+import "./chunk-LFKP64TQ.js";
+import "./chunk-37M4NISG.js";
 export {
   buildCliFlagsSummary,
   buildLabels,

package/dist/{chunk-KJH2T5TQ.js → chunk-37M4NISG.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "@parity/product-deploy",
-  version: "0.7.28-rc.0",
+  version: "0.7.28",
   private: false,
   repository: {
     type: "git",

package/dist/{chunk-43HLT335.js → chunk-64KTKZ7H.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-MFTODIIT.js";
+} from "./chunk-LFKP64TQ.js";
 
 // src/version-check.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-DNXH4QTI.js → chunk-6Y3XJGV7.js}

@@ -1,16 +1,16 @@
 import {
   isTestnetSpecName
-} from "./chunk-QMYW3D6E.js";
+} from "./chunk-Y7XKC43A.js";
 import {
   captureWarning,
   setDeployAttribute,
   setDeploySentryTag,
   truncateAddress,
   withSpan
-} from "./chunk-MFTODIIT.js";
+} from "./chunk-LFKP64TQ.js";
 import {
   validateContractAddresses
-} from "./chunk-OITUIM2E.js";
+} from "./chunk-HZKRLQLG.js";
 import {
   NonRetryableError
 } from "./chunk-ZOC4GITL.js";
@@ -93,7 +93,8 @@ var CONNECTION_TIMEOUT_MS = 3e4;
 var OPERATION_TIMEOUT_MS = 3e5;
 var TX_TIMEOUT_MS = 9e4;
 var TX_CHAIN_TIME_BUDGET_MS = 18e4;
-var TX_WALL_CLOCK_CEILING_MS = 10 * 60 * 1e3;
+var TX_WALL_CLOCK_CEILING_MS = 24e4;
+var TX_NO_PROGRESS_MS = 9e4;
 var WS_HEARTBEAT_TIMEOUT_MS = 3e5;
 var DOTNS_TX_MAX_ATTEMPTS = 3;
 function classifyTxRetryDecision(err) {
@@ -104,6 +105,7 @@ function classifyTxRetryDecision(err) {
   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";
+  if (lower.includes("transaction watcher silent")) return "retry";
   return "abort";
 }
 var DEFAULT_MNEMONIC = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
@@ -400,8 +402,8 @@ function sanitizeDomainLabel(label) {
 function validateDomainLabel(label, opts = {}) {
   if (!/^[a-z0-9-]{3,}$/.test(label)) throw new Error("Invalid domain label: must contain only lowercase letters, digits, and hyphens, min 3 chars");
   if (label.startsWith("-") || label.endsWith("-")) throw new Error("Invalid domain label: cannot start or end with hyphen");
-  const sanitized = sanitizeDomainLabel(label);
-  if (/-\d+$/.test(sanitized)) {
+  const sanitized = opts.skipSanitize ? label : sanitizeDomainLabel(label);
+  if (!opts.skipSanitize && /-\d+$/.test(sanitized)) {
     const baseWithHyphen = sanitized.replace(/\d+$/, "");
     const dropHyphen = sanitized.replace(/-(\d+)$/, "$1");
     const insertSegment = sanitized.replace(/-(\d+)$/, "-pr$1");
@@ -471,7 +473,7 @@ function parseDomainName(input) {
     return { isSubdomain: false, label: sanitized, sublabel: null, parentLabel: null, fullName: `${sanitized}.dot` };
   }
   if (parts.length === 2) {
-    const sanitizedSub = validateDomainLabel(parts[0], { checkReserved: false });
+    const sanitizedSub = validateDomainLabel(parts[0], { checkReserved: false, skipSanitize: true });
     const sanitizedParent = validateDomainLabel(parts[1]);
     const fullLabel = `${sanitizedSub}.${sanitizedParent}`;
     return { isSubdomain: true, label: fullLabel, sublabel: sanitizedSub, parentLabel: sanitizedParent, fullName: `${fullLabel}.dot` };
@@ -578,6 +580,8 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
         }
       };
       const startWallClockMs = Date.now();
+      let lastEventAt = Date.now();
+      let lastEventType = "(none)";
       let startChainTimeMs = null;
       const poll = async () => {
         if (settled) return;
@@ -612,6 +616,12 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
             finish(reject)(new Error(`Transaction not included after ${Math.floor(chainElapsedMs / 1e3)}s of chain progress (budget=${TX_CHAIN_TIME_BUDGET_MS / 1e3}s)`));
             return;
           }
+          const silentMs = Date.now() - lastEventAt;
+          if (silentMs > TX_NO_PROGRESS_MS) {
+            statusCallback("failed");
+            finish(reject)(new Error(`transaction watcher silent for ${Math.floor(silentMs / 1e3)}s after ${lastEventType}`));
+            return;
+          }
         } catch {
         }
         if (!settled) deadlinePoller = setTimeout(poll, 6e3);
@@ -620,6 +630,8 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
       try {
         sub = extrinsic.signSubmitAndWatch(signer, { mortality: { mortal: true, period: 256 } }).subscribe({
           next: (event) => {
+            lastEventAt = Date.now();
+            lastEventType = event.type;
             const transactionHash = event.txHash?.toString();
             switch (event.type) {
               case "signed":
@@ -634,7 +646,7 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
               case "finalized": {
                 if (event.dispatchError || event.ok === false) {
                   statusCallback("failed");
-                  finish(reject)(new Error(`Transaction failed: ${event.dispatchError?.toString?.() ?? "dispatch error"}`));
+                  finish(reject)(new Error(`Transaction failed: ${formatDispatchError(event.dispatchError)}`));
                   return;
                 }
                 const block = event.block ? { hash: String(event.block.hash), number: Number(event.block.number) } : void 0;
@@ -721,7 +733,12 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
       } catch {
       }
     }
-    const prep = await this.dryRunReviveCall(contractAddress, value, encodedData, signerSubstrateAddress, { functionName, args, contracts });
+    const prep = await withSpan(
+      "chain.dry_run",
+      `dry-run ${functionName ?? "Revive.call"}`,
+      { "chain.function_name": functionName ?? "Revive.call" },
+      () => this.dryRunReviveCall(contractAddress, value, encodedData, signerSubstrateAddress, { functionName, args, contracts })
+    );
     const buildExtrinsic = () => this.client.tx.Revive.call({ dest: contractAddress, value, weight_limit: prep.weight_limit, storage_deposit_limit: prep.storage_deposit_limit, data: Binary.fromHex(encodedData) });
     let nonceFallback;
     if (useNoncePolling) {
@@ -731,7 +748,12 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
       } catch {
       }
     }
-    return await this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Revive.call", { nonceFallback, verifyEffect });
+    return await withSpan(
+      "chain.tx.submit",
+      `sign+submit ${functionName ?? "Revive.call"}`,
+      { "chain.function_name": functionName ?? "Revive.call", "chain.use_nonce_polling": Boolean(useNoncePolling) },
+      () => this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Revive.call", { nonceFallback, verifyEffect })
+    );
   }
   // Dry-runs each call individually, then wraps them in a single
   // Utility.batch_all extrinsic. batch_all is atomic over inner calls — only
@@ -740,7 +762,12 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
   async submitBatchedTransactions(calls, signerSubstrateAddress, signer, statusCallback) {
     if (calls.length === 0) throw new Error("submitBatchedTransactions: at least one call required");
     await this.ensureAccountMapped(signerSubstrateAddress, signer);
-    const preps = await Promise.all(calls.map((c) => this.dryRunReviveCall(c.contractAddress, c.value, c.encodedData, signerSubstrateAddress, { functionName: c.functionName, args: c.args })));
+    const preps = await withSpan(
+      "chain.dry_run",
+      "dry-run Utility.batch_all",
+      { "chain.function_name": "Utility.batch_all" },
+      () => Promise.all(calls.map((c) => this.dryRunReviveCall(c.contractAddress, c.value, c.encodedData, signerSubstrateAddress, { functionName: c.functionName, args: c.args })))
+    );
     const buildExtrinsic = () => {
       const inners = calls.map((c, i) => this.client.tx.Revive.call({
         dest: c.contractAddress,
@@ -751,9 +778,24 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
       }).decodedCall);
       return this.client.tx.Utility.batch_all({ calls: inners });
     };
-    return await this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Utility.batch_all");
+    return await withSpan(
+      "chain.tx.submit",
+      "sign+submit Utility.batch_all",
+      { "chain.function_name": "Utility.batch_all" },
+      () => this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Utility.batch_all")
+    );
   }
 };
+function formatDispatchError(err) {
+  if (err === void 0 || err === null) return "dispatch error";
+  if (typeof err === "string") return err;
+  try {
+    const out = JSON.stringify(err, (_k, v) => typeof v === "bigint" ? v.toString() : v);
+    return typeof out === "string" ? out : "dispatch error";
+  } catch {
+    return String(err);
+  }
+}
 function logTxResolution(res) {
   setDeployAttribute(ATTR_TX_RESOLUTION_KIND, res.kind);
   if (res.kind === TX_KIND_HASH) {
@@ -1319,13 +1361,39 @@ var DotNS = class {
       const parentNode = namehash(`${parentLabel}.dot`);
       const subnodeNode = namehash(`${sublabel}.${parentLabel}.dot`);
       const subnodeRecord = { parentNode, subLabel: sublabel, parentLabel, owner: this.evmAddress };
+      const MAX_VERIFY_CHAIN_SECONDS = 30;
+      const POLL_INTERVAL_MS = 2e3;
+      const verifyEffect = async () => {
+        const wrapper = this.clientWrapper;
+        if (!this.connected || !wrapper) return false;
+        const startChainMs = Number(await wrapper.client.query.Timestamp.Now.getValue());
+        let lastPrintedElapsed = -1;
+        while (true) {
+          const liveWrapper = this.clientWrapper;
+          if (!this.connected || !liveWrapper) return false;
+          const [ownership, nowChainMs] = await Promise.all([
+            this.checkSubdomainOwnership(sublabel, parentLabel),
+            liveWrapper.client.query.Timestamp.Now.getValue().then(Number)
+          ]);
+          if (ownership.owned) return true;
+          const chainElapsed = (nowChainMs - startChainMs) / 1e3;
+          if (chainElapsed >= MAX_VERIFY_CHAIN_SECONDS) return false;
+          const floored = Math.floor(chainElapsed);
+          if (floored > lastPrintedElapsed) {
+            console.log(`   Awaiting subnode finalization [verifyEffect] (chain time +${floored}s / ${MAX_VERIFY_CHAIN_SECONDS}s)...`);
+            lastPrintedElapsed = floored;
+          }
+          await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        }
+      };
       const txResolution = await this.submitBatchedContractCalls(
         [
           { contractAddress: this._contracts.DOTNS_REGISTRY, abi: DOTNS_REGISTRY_ABI, functionName: "setSubnodeOwner", args: [subnodeRecord] },
           { contractAddress: this._contracts.DOTNS_REGISTRY, abi: DOTNS_REGISTRY_ABI, functionName: "setResolver", args: [subnodeNode, this._contracts.DOTNS_CONTENT_RESOLVER] }
         ],
         (s) => console.log(`      ${s}`),
-        `Utility.batch_all (register ${sublabel}.${parentLabel}.dot)`
+        `Utility.batch_all (register ${sublabel}.${parentLabel}.dot)`,
+        { verifyEffect }
       );
       logTxResolution(txResolution);
       if (txResolution.kind === TX_KIND_HASH) {
@@ -1353,7 +1421,7 @@ var DotNS = class {
    * budget for every subsequent call, on the assumption sibling
    * registry/resolver writes are similarly sized.
    */
-  async submitBatchedContractCalls(calls, statusCallback, label) {
+  async submitBatchedContractCalls(calls, statusCallback, label, { verifyEffect } = {}) {
     this.ensureConnected();
     if (!this.clientWrapper) throw new Error(`${label}: polkadot-api client not available`);
     if (calls.length === 0) throw new Error(`${label}: at least one inner call required`);
@@ -1402,7 +1470,7 @@ var DotNS = class {
       return client.tx.Utility.batch_all({ calls: inner.map((c) => c.decodedCall) });
     };
     return await withTimeout(
-      this.clientWrapper.signAndSubmitWithRetry(buildBatch, this.signer, statusCallback, label),
+      this.clientWrapper.signAndSubmitWithRetry(buildBatch, this.signer, statusCallback, label, { verifyEffect }),
       OPERATION_TIMEOUT_MS,
       label
     );
@@ -1527,7 +1595,33 @@ var DotNS = class {
       this.ensureConnected();
       console.log(`   Setting text[${key}]: ${value}`);
       const node = namehash(`${domainName}.dot`);
-      const textTxRes = await this.contractTransaction(this._contracts.DOTNS_CONTENT_RESOLVER, 0n, DOTNS_TEXT_RESOLVER_ABI, "setText", [node, key, value], (s) => console.log(`      ${s}`), { useNoncePolling: true });
+      const MAX_VERIFY_CHAIN_SECONDS = 30;
+      const TEXT_POLL_INTERVAL_MS = 2e3;
+      const verifyEffect = async () => {
+        const wrapper = this.clientWrapper;
+        if (!this.connected || !wrapper) return false;
+        const startChainMs2 = Number(await wrapper.client.query.Timestamp.Now.getValue());
+        let lastPrintedElapsed2 = -1;
+        while (true) {
+          const liveWrapper = this.clientWrapper;
+          if (!this.connected || !liveWrapper) return false;
+          const [onChainRaw, nowChainMs] = await Promise.all([
+            this.contractCallNullable(this._contracts.DOTNS_CONTENT_RESOLVER, DOTNS_TEXT_RESOLVER_ABI, "text", [node, key]),
+            liveWrapper.client.query.Timestamp.Now.getValue().then(Number)
+          ]);
+          const onChain = onChainRaw ?? "";
+          if (onChain === value) return true;
+          const chainElapsed = (nowChainMs - startChainMs2) / 1e3;
+          if (chainElapsed >= MAX_VERIFY_CHAIN_SECONDS) return false;
+          const floored = Math.floor(chainElapsed);
+          if (floored > lastPrintedElapsed2) {
+            console.log(`   Awaiting text finalization [verifyEffect] (chain time +${floored}s / ${MAX_VERIFY_CHAIN_SECONDS}s)...`);
+            lastPrintedElapsed2 = floored;
+          }
+          await new Promise((r) => setTimeout(r, TEXT_POLL_INTERVAL_MS));
+        }
+      };
+      const textTxRes = await this.contractTransaction(this._contracts.DOTNS_CONTENT_RESOLVER, 0n, DOTNS_TEXT_RESOLVER_ABI, "setText", [node, key, value], (s) => console.log(`      ${s}`), { useNoncePolling: true, verifyEffect });
       logTxResolution(textTxRes);
       const MAX_CHAIN_WAIT_SECONDS = 90;
       const POLL_INTERVAL_MS = 2e3;
@@ -2302,6 +2396,7 @@ export {
   TX_TIMEOUT_MS,
   TX_CHAIN_TIME_BUDGET_MS,
   TX_WALL_CLOCK_CEILING_MS,
+  TX_NO_PROGRESS_MS,
   WS_HEARTBEAT_TIMEOUT_MS,
   DOTNS_TX_MAX_ATTEMPTS,
   classifyTxRetryDecision,
@@ -2329,6 +2424,7 @@ export {
   parseDomainName,
   parseProofOfPersonhoodStatus,
   popStatusName,
+  formatDispatchError,
   formatPersonhoodRemediation,
   formatPopShortfallReason,
   DotNS,

package/dist/{chunk-QTZNULSH.js → chunk-7NKOV5SU.js}

@@ -1,6 +1,6 @@
 import {
   captureWarning
-} from "./chunk-MFTODIIT.js";
+} from "./chunk-LFKP64TQ.js";
 
 // src/chunk-probe.ts
 import { Twox128, Blake2128Concat, decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";

package/dist/{chunk-OITUIM2E.js → chunk-HZKRLQLG.js}

@@ -17,7 +17,6 @@ var environments_default = {
       backend: "https://polkadot-app-stg.parity.io/",
       ipfs: "https://previewnet.substrate.dev",
       autoAccountMapping: true,
-      bulletinAuthorizeV2: true,
       registerStorageDeposit: 2e12,
       contracts: {
         DOTNS_PROTOCOL_REGISTRY: "0xc07A2F24387DA27283CD87b9F24573b74C9e0c9b",
@@ -64,7 +63,6 @@ var environments_default = {
       ipfs: "https://paseo-bulletin-next-ipfs.polkadot.io",
       docsUrl: "https://sre.teleport.parity.io/environments/paseo-next/",
       autoAccountMapping: true,
-      bulletinAuthorizeV2: true,
       nativeToEthRatio: 1e8,
       registerStorageDeposit: 2e12,
       popSelfServe: {
@@ -471,7 +469,6 @@ function resolveEndpoints(doc, envId) {
     envName: env.name,
     ipfs: env.ipfs,
     autoAccountMapping: env.autoAccountMapping ?? false,
-    bulletinAuthorizeV2: env.bulletinAuthorizeV2 ?? false,
     contracts: env.contracts ?? {},
     nativeToEthRatio: BigInt(env.nativeToEthRatio ?? 1e6),
     ...env.registerStorageDeposit !== void 0 ? { registerStorageDeposit: BigInt(env.registerStorageDeposit) } : {}

package/dist/{chunk-KHVTYIIX.js → chunk-IW3X2MJF.js}

@@ -10,6 +10,7 @@ function computeStats(input) {
   return {
     manifestSource: input.manifestSource,
     manifestFetchAttempts: input.manifestFetchAttempts,
+    manifestFetchReason: input.manifestFetchReason,
     manifestBytes: input.manifestBytes ?? 0,
     framework: input.framework,
     filesTotal: input.filesTotal,
@@ -46,6 +47,7 @@ function telemetryAttributes(s) {
   return {
     "deploy.cache.manifest_source": s.manifestSource,
     "deploy.cache.manifest_fetch_attempts": String(s.manifestFetchAttempts),
+    "deploy.cache.manifest_fetch_reason": s.manifestFetchReason ?? "",
     "deploy.cache.manifest_bytes": String(s.manifestBytes),
     "deploy.cache.framework": s.framework ?? "",
     "deploy.cache.hit_rate": String(Math.round(hitRate * 1e3) / 1e3),

package/dist/chunk-L2SKSKB6.js

@@ -0,0 +1,308 @@
+import {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  parseManifest
+} from "./chunk-S7EM5VMW.js";
+
+// src/manifest-fetch.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as Sentry from "@sentry/node";
+import { CarReader } from "@ipld/car/reader";
+import * as dagPB from "@ipld/dag-pb";
+import { CID } from "multiformats/cid";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SIDECAR_FILENAME = ".last_deploy_cid";
+var RANGE_TIERS = [
+  "bytes=0-4095",
+  "bytes=0-65535",
+  "bytes=0-1048575",
+  void 0
+  // full body
+];
+function getCacheDir() {
+  const override = process.env.BULLETIN_DEPLOY_CACHE_DIR;
+  if (override) return path.join(override, "manifests");
+  if (process.platform === "win32") return null;
+  const xdg = process.env.XDG_CACHE_HOME;
+  if (xdg) return path.join(xdg, "bulletin-deploy", "manifests");
+  return path.join(os.homedir(), ".cache", "bulletin-deploy", "manifests");
+}
+function readPersistentLocalManifest(domain, prevContenthash) {
+  if (!domain) return null;
+  const cacheDir = getCacheDir();
+  if (!cacheDir) return null;
+  const cidPath = path.join(cacheDir, `${domain}.cid`);
+  const manifestPath = path.join(cacheDir, `${domain}.json`);
+  let storedCid;
+  try {
+    storedCid = fs.readFileSync(cidPath, "utf8").trim();
+  } catch {
+    return null;
+  }
+  if (storedCid !== prevContenthash) return null;
+  let text;
+  try {
+    text = fs.readFileSync(manifestPath, "utf8");
+  } catch {
+    return null;
+  }
+  const parsed = parseManifest(text);
+  if (!parsed.ok) return null;
+  return {
+    source: "embedded",
+    manifest: parsed.manifest,
+    attempts: 0,
+    bytesDownloaded: text.length
+  };
+}
+function writePersistentLocalManifest(domain, storageCid, manifestJson) {
+  const cacheDir = getCacheDir();
+  if (!cacheDir) return;
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const cidPath = path.join(cacheDir, `${domain}.cid`);
+    const manifestPath = path.join(cacheDir, `${domain}.json`);
+    const cidTmp = `${cidPath}.${process.pid}.tmp`;
+    const manifestTmp = `${manifestPath}.${process.pid}.tmp`;
+    fs.writeFileSync(cidTmp, storageCid);
+    fs.renameSync(cidTmp, cidPath);
+    fs.writeFileSync(manifestTmp, manifestJson);
+    fs.renameSync(manifestTmp, manifestPath);
+  } catch {
+  }
+}
+async function fetchOneTier(url, tierIndex, budgetRemaining) {
+  const rangeHeader = RANGE_TIERS[tierIndex];
+  const rangeLabel = rangeHeader != null ? rangeHeader.replace("bytes=", "") : "full";
+  const isFullBody = rangeHeader === void 0;
+  return Sentry.startSpan(
+    { op: "manifest.fetch.tier", name: `tier ${tierIndex} ${rangeLabel}` },
+    async (span) => {
+      span.setAttribute("manifest.tier.index", String(tierIndex));
+      span.setAttribute("manifest.tier.range", rangeLabel);
+      span.setAttribute("manifest.tier.http_status", "");
+      span.setAttribute("manifest.tier.bytes", "0");
+      span.setAttribute("manifest.tier.wait_ms", "0");
+      span.setAttribute("manifest.tier.read_ms", "0");
+      span.setAttribute("manifest.tier.error", "");
+      const headers = {};
+      if (rangeHeader !== void 0) headers.Range = rangeHeader;
+      let res;
+      const fetchStart = Date.now();
+      try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), Math.max(100, budgetRemaining));
+        try {
+          res = await fetch(url, { headers, signal: ctrl.signal });
+        } finally {
+          clearTimeout(timer);
+        }
+      } catch (e) {
+        const isAbort = e?.name === "AbortError";
+        const outcome = isAbort ? "timeout" : "network_error";
+        const msg = e?.message ?? String(e);
+        span.setAttribute("manifest.tier.outcome", outcome);
+        span.setAttribute("manifest.tier.wait_ms", String(Date.now() - fetchStart));
+        span.setAttribute("manifest.tier.error", msg);
+        return { outcome, reason: `${outcome}: ${msg}`, bytes: 0 };
+      }
+      const waitMs = Date.now() - fetchStart;
+      span.setAttribute("manifest.tier.wait_ms", String(waitMs));
+      span.setAttribute("manifest.tier.http_status", String(res.status));
+      if (res.status === 404) {
+        span.setAttribute("manifest.tier.outcome", "http_404");
+        return { outcome: "http_404", reason: "gateway 404", bytes: 0 };
+      }
+      if (res.status !== 200 && res.status !== 206) {
+        const outcome = `http_${res.status}`;
+        span.setAttribute("manifest.tier.outcome", outcome);
+        span.setAttribute("manifest.tier.error", `HTTP ${res.status}`);
+        return { outcome, reason: `gateway HTTP ${res.status}`, bytes: 0 };
+      }
+      let carBytes;
+      const readStart = Date.now();
+      try {
+        const buf = await res.arrayBuffer();
+        carBytes = new Uint8Array(buf);
+        span.setAttribute("manifest.tier.bytes", String(carBytes.length));
+        span.setAttribute("manifest.tier.read_ms", String(Date.now() - readStart));
+      } catch (e) {
+        span.setAttribute("manifest.tier.read_ms", String(Date.now() - readStart));
+        const msg = `body read error: ${e?.message ?? e}`;
+        span.setAttribute("manifest.tier.outcome", "body_read_error");
+        span.setAttribute("manifest.tier.error", msg);
+        return { outcome: "body_read_error", reason: msg, bytes: 0 };
+      }
+      let manifestBytes;
+      try {
+        manifestBytes = await extractManifestFromCar(carBytes);
+      } catch (e) {
+        const msg = `CAR parse error: ${e?.message ?? e}`;
+        const outcome = isFullBody ? "car_parse_error" : "car_truncated";
+        span.setAttribute("manifest.tier.outcome", outcome);
+        span.setAttribute("manifest.tier.error", msg);
+        return { outcome, reason: msg, bytes: carBytes.length };
+      }
+      if (!manifestBytes) {
+        const outcome = isFullBody ? "manifest_missing" : "manifest_not_in_slice";
+        const msg = isFullBody ? "no .bulletin-deploy/manifest.json in deployed DAG" : `manifest not in slice tier ${tierIndex}`;
+        span.setAttribute("manifest.tier.outcome", outcome);
+        span.setAttribute("manifest.tier.error", msg);
+        return { outcome, reason: msg, bytes: carBytes.length };
+      }
+      const text = new TextDecoder().decode(manifestBytes);
+      const parsed = parseManifest(text);
+      if (parsed.ok) {
+        span.setAttribute("manifest.tier.outcome", "success");
+        return { outcome: "success", reason: "", bytes: carBytes.length, manifest: parsed.manifest };
+      }
+      span.setAttribute("manifest.tier.outcome", "manifest_parse_error");
+      span.setAttribute("manifest.tier.error", parsed.error);
+      return { outcome: "manifest_parse_error", reason: parsed.error, bytes: carBytes.length };
+    }
+  );
+}
+async function fetchAcrossTiers(url, budget, start) {
+  let lastReason = "unknown";
+  let attempts = 0;
+  let bytesDownloaded = 0;
+  for (let tier = 0; tier < RANGE_TIERS.length; tier++) {
+    const elapsed = Date.now() - start;
+    if (elapsed > budget) {
+      return { outcome: "retryable", reason: `budget exceeded: ${lastReason}`, attempts, bytesDownloaded };
+    }
+    attempts++;
+    const result = await fetchOneTier(url, tier, budget - elapsed);
+    bytesDownloaded += result.bytes;
+    if (result.outcome === "success") {
+      return { outcome: "success", manifest: result.manifest, attempts, bytesDownloaded };
+    }
+    if (result.outcome === "http_404") {
+      return { outcome: "404", attempts, bytesDownloaded };
+    }
+    if (result.outcome === "car_parse_error" || result.outcome === "manifest_missing" || result.outcome === "manifest_parse_error") {
+      return { outcome: "parse_error", reason: result.reason, attempts, bytesDownloaded };
+    }
+    if (result.outcome === "body_read_error" && tier === RANGE_TIERS.length - 1) {
+      return { outcome: "parse_error", reason: result.reason, attempts, bytesDownloaded };
+    }
+    lastReason = result.reason;
+  }
+  return { outcome: "retryable", reason: `tiers exhausted: ${lastReason}`, attempts, bytesDownloaded };
+}
+async function fetchPreviousManifest(prevContenthash, options = {}) {
+  if (prevContenthash === null) return { source: "none" };
+  const local = readPersistentLocalManifest(options.domain, prevContenthash);
+  if (local) return local;
+  const gatewayList = (options.gateways ?? (options.gateway ? [options.gateway] : [])).map((g) => g.replace(/\/$/, ""));
+  const budget = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const start = Date.now();
+  let lastReason = "unknown";
+  let totalAttempts = 0;
+  let bytesDownloaded = 0;
+  for (const gatewayRaw of gatewayList) {
+    const gateway = gatewayRaw.replace(/\/ipfs\/?$/, "");
+    const url = `${gateway}/ipfs/${prevContenthash}`;
+    const gatewayStart = Date.now();
+    const tierResult = await Sentry.startSpan(
+      {
+        op: "manifest.fetch",
+        name: `manifest fetch ${prevContenthash.slice(0, 12)}`,
+        attributes: {
+          "manifest.fetch.gateway": gateway,
+          "manifest.fetch.cid": prevContenthash.slice(0, 12),
+          "manifest.fetch.budget_ms": String(budget)
+        }
+      },
+      async (span) => {
+        const result = await fetchAcrossTiers(url, budget, start);
+        span.setAttribute("manifest.fetch.outcome", result.outcome);
+        span.setAttribute("manifest.fetch.attempts", String(result.attempts));
+        span.setAttribute("manifest.fetch.bytes", String(result.bytesDownloaded));
+        span.setAttribute("manifest.fetch.elapsed_ms", String(Date.now() - gatewayStart));
+        return result;
+      }
+    );
+    if (tierResult.outcome === "success") {
+      return {
+        source: "embedded",
+        manifest: tierResult.manifest,
+        attempts: totalAttempts + tierResult.attempts,
+        bytesDownloaded: bytesDownloaded + tierResult.bytesDownloaded
+      };
+    }
+    if (tierResult.outcome === "404" || tierResult.outcome === "parse_error") {
+      return {
+        source: "heuristic_fallback",
+        reason: tierResult.outcome === "404" ? "gateway 404" : tierResult.reason,
+        attempts: totalAttempts + tierResult.attempts,
+        bytesDownloaded: bytesDownloaded + tierResult.bytesDownloaded
+      };
+    }
+    lastReason = tierResult.reason;
+    totalAttempts += tierResult.attempts;
+    bytesDownloaded += tierResult.bytesDownloaded;
+  }
+  return { source: "heuristic_fallback", reason: `all gateways exhausted: ${lastReason}`, attempts: totalAttempts, bytesDownloaded };
+}
+async function extractManifestFromCar(carBytes) {
+  const reader = await CarReader.fromBytes(carBytes);
+  const roots = await reader.getRoots();
+  if (roots.length === 0) return null;
+  const blocks = /* @__PURE__ */ new Map();
+  for await (const { cid, bytes } of reader.blocks()) {
+    blocks.set(cid.toString(), bytes);
+  }
+  return walkDagToManifest(blocks, roots[0].toString());
+}
+async function walkDagToManifest(blocks, rootCid) {
+  const rootBytes = blocks.get(rootCid);
+  if (!rootBytes) return null;
+  const rootNode = dagPB.decode(rootBytes);
+  const bdLink = (rootNode.Links ?? []).find((l) => l.Name === MANIFEST_DIR);
+  if (!bdLink) return null;
+  const bdBytes = blocks.get(bdLink.Hash.toString());
+  if (!bdBytes) return null;
+  const bdNode = dagPB.decode(bdBytes);
+  const manLink = (bdNode.Links ?? []).find((l) => l.Name === MANIFEST_FILENAME);
+  if (!manLink) return null;
+  const manCidStr = manLink.Hash.toString();
+  const manCid = CID.parse(manCidStr);
+  const manBytes = blocks.get(manCidStr);
+  if (!manBytes) return null;
+  if (manCid.code === 85) {
+    return manBytes;
+  }
+  if (manCid.code === 112) {
+    const node = dagPB.decode(manBytes);
+    const parts = [];
+    let total = 0;
+    for (const link of node.Links ?? []) {
+      const leafBytes = blocks.get(link.Hash.toString());
+      if (!leafBytes) return null;
+      parts.push(leafBytes);
+      total += leafBytes.length;
+    }
+    const out = new Uint8Array(total);
+    let pos = 0;
+    for (const part of parts) {
+      out.set(part, pos);
+      pos += part.length;
+    }
+    return out;
+  }
+  return null;
+}
+
+export {
+  DEFAULT_TIMEOUT_MS,
+  SIDECAR_FILENAME,
+  getCacheDir,
+  readPersistentLocalManifest,
+  writePersistentLocalManifest,
+  fetchPreviousManifest,
+  extractManifestFromCar,
+  walkDagToManifest
+};