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

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-JFL64IZ4.js";
+import "./chunk-XYITGX7M.js";
+import "./chunk-ZOC5WRIG.js";
+import "./chunk-VWPVG4DQ.js";
 export {
   buildCliFlagsSummary,
   buildLabels,

package/dist/{chunk-QMYW3D6E.js → chunk-A5PSVZFF.js}

@@ -1,3 +1,7 @@
+import {
+  setDeployAttribute
+} from "./chunk-ZOC5WRIG.js";
+
 // src/pool.ts
 import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import { DEV_PHRASE, entropyToMiniSecret, mnemonicToEntropy } from "@polkadot-labs/hdkd-helpers";
@@ -14,7 +18,6 @@ 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);
@@ -30,23 +33,19 @@ function derivePoolAccounts(poolSize = 10, mnemonic = DEV_PHRASE) {
   }
   return accounts;
 }
-function isAuthorizationSufficient(auth, currentBlock, check = {}) {
+function isAuthorizationSufficient(auth, currentBlock, needs) {
   if (auth === void 0) return false;
   if (Number(auth.expiration ?? 0) <= currentBlock) return false;
-  if (check.bulletinAuthorizeV2 && check.needs) {
+  if (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;
+    if (txsRemaining < needs.txs) return false;
+    if (bytesRemaining < 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 };
+function selectAccount(authorizations, random = Math.random) {
+  return { account: authorizations[Math.floor(random() * authorizations.length)], eligibleCount: authorizations.length };
 }
 async function fetchPoolAuthorizations(api, accounts) {
   const results = await Promise.all(
@@ -145,83 +144,59 @@ function clampU32(n, name) {
   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) {
+function markBulletinAuthGranted() {
+  setDeployAttribute("deploy.unblock.bulletin_auth.fired", "true");
+  setDeployAttribute("deploy.unblock.bulletin_auth.granted_txs", String(TOPUP_TRANSACTIONS));
+  setDeployAttribute("deploy.unblock.bulletin_auth.granted_bytes", String(TOPUP_BYTES));
+}
+async function ensureAuthorized(api, address, label, 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;
+  if (isAuthorizationSufficient(auth, currentBlock, needs)) 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})`);
-  }
+  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`);
+  markBulletinAuthGranted();
 }
-async function topUpBy(api, address, needs, label, bulletinAuthorizeV2) {
+async function topUpBy(api, address, needs, label) {
   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 })) {
+  if (isAuthorizationSufficient(currentAuth, currentBlock, needs)) {
     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}.`);
-    }
+    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.`);
     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}`);
-  }
+  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`);
+  markBulletinAuthGranted();
 }
-async function bootstrapPool(bulletinRpc, poolSize = 10, mnemonic, opts = {}) {
+async function bootstrapPool(bulletinRpc, poolSize = 10, mnemonic) {
   console.log(`Bootstrapping ${poolSize} pool accounts on ${bulletinRpc}...
 `);
   await cryptoWaitReady();
@@ -238,40 +213,19 @@ async function bootstrapPool(bulletinRpc, poolSize = 10, mnemonic, opts = {}) {
   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})
+  console.log(`Authorizing accounts (${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB)
 `);
-  }
   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 tx = api.tx.TransactionStorage.authorize_account({
+        who: account.address,
+        transactions: clampU32(BigInt(TOPUP_TRANSACTIONS), "transactions"),
+        bytes: TOPUP_BYTES
+      });
       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}`);
-      }
+      console.log(`  Authorized: ${TOPUP_TRANSACTIONS} txs / ${Number(TOPUP_BYTES) / 1e6}MB`);
     } catch (e) {
       console.log(`  Authorization failed: ${e.message?.slice(0, 80)}`);
     }

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-ADNBLFDP.js → chunk-JFL64IZ4.js}

@@ -2,11 +2,11 @@ import {
   classifyErrorArea,
   isInteractive,
   promptYesNo
-} from "./chunk-43HLT335.js";
+} from "./chunk-XYITGX7M.js";
 import {
   VERSION,
   getCurrentSentryTraceId
-} from "./chunk-MFTODIIT.js";
+} from "./chunk-ZOC5WRIG.js";
 
 // src/bug-report.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-NF2FL4ZO.js → chunk-JZRWI7D2.js}

@@ -6,15 +6,15 @@ import {
   resolveDotnsConnectOptions,
   storeDirectory,
   storeFile
-} from "./chunk-P6CHOMN3.js";
+} from "./chunk-OOXMLONF.js";
 import {
   DotNS
-} from "./chunk-DNXH4QTI.js";
+} from "./chunk-ZZCR63N2.js";
 import {
   getPopSelfServeConfig,
   loadEnvironments,
   resolveEndpoints
-} from "./chunk-OITUIM2E.js";
+} from "./chunk-HZKRLQLG.js";
 import {
   NonRetryableError
 } from "./chunk-ZOC4GITL.js";

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
+};