npm - permaweb-deploy - Versions diffs - 4.0.0 → 5.0.0 - Mend

permaweb-deploy 4.0.0 → 5.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (97) hide show

package/README.md +174 -511
package/dist/chunks/chalk-BP_cCc9v.js +49 -0
package/dist/chunks/chalk-BP_cCc9v.js.map +1 -0
package/dist/chunks/{display-WYdGiMxZ.js → display-CZV6KUcG.js} +2 -2
package/dist/chunks/{display-WYdGiMxZ.js.map → display-CZV6KUcG.js.map} +1 -1
package/dist/chunks/upload-workflow-f3hExxtV.js +620 -0
package/dist/chunks/upload-workflow-f3hExxtV.js.map +1 -0
package/dist/chunks/{uploader-CC-qBdlV.js → uploader-Bz9jraY2.js} +15 -17
package/dist/chunks/uploader-Bz9jraY2.js.map +1 -0
package/dist/commands/deploy.js +72 -98
package/dist/commands/deploy.js.map +1 -1
package/dist/commands/hyperbeam-uploaders.js +48 -0
package/dist/commands/hyperbeam-uploaders.js.map +1 -0
package/dist/commands/upload.js +11 -12
package/dist/commands/upload.js.map +1 -1
package/dist/constants/flags.js +66 -97
package/dist/constants/flags.js.map +1 -1
package/dist/index.js +1 -0
package/dist/index.js.map +1 -1
package/dist/prompts/names.js +13 -0
package/dist/prompts/names.js.map +1 -0
package/dist/src/commands/deploy.d.ts +1 -1
package/dist/src/commands/deploy.d.ts.map +1 -1
package/dist/src/commands/hyperbeam-uploaders.d.ts +14 -0
package/dist/src/commands/hyperbeam-uploaders.d.ts.map +1 -0
package/dist/src/commands/upload.d.ts +1 -1
package/dist/src/commands/upload.d.ts.map +1 -1
package/dist/src/constants/flags.d.ts +271 -100
package/dist/src/constants/flags.d.ts.map +1 -1
package/dist/src/index.d.ts +2 -0
package/dist/src/index.d.ts.map +1 -1
package/dist/src/prompts/names.d.ts +2 -0
package/dist/src/prompts/names.d.ts.map +1 -0
package/dist/src/types/index.d.ts +0 -29
package/dist/src/types/index.d.ts.map +1 -1
package/dist/src/utils/__tests__/hyperbeam-uploaders-cli.test.d.ts +2 -0
package/dist/src/utils/__tests__/hyperbeam-uploaders-cli.test.d.ts.map +1 -0
package/dist/src/utils/__tests__/names.test.d.ts +2 -0
package/dist/src/utils/__tests__/names.test.d.ts.map +1 -0
package/dist/src/utils/__tests__/permawebos-bundlers.test.d.ts +2 -0
package/dist/src/utils/__tests__/permawebos-bundlers.test.d.ts.map +1 -0
package/dist/src/utils/config-resolver.d.ts +29 -11
package/dist/src/utils/config-resolver.d.ts.map +1 -1
package/dist/src/utils/constants.d.ts +0 -2
package/dist/src/utils/constants.d.ts.map +1 -1
package/dist/src/utils/hyperbeam-uploader.d.ts +7 -0
package/dist/src/utils/hyperbeam-uploader.d.ts.map +1 -1
package/dist/src/utils/hyperbeam-uploaders-cli.d.ts +7 -0
package/dist/src/utils/hyperbeam-uploaders-cli.d.ts.map +1 -0
package/dist/src/utils/legacy-bundler-uploader.d.ts +29 -0
package/dist/src/utils/legacy-bundler-uploader.d.ts.map +1 -0
package/dist/src/utils/names.d.ts +46 -0
package/dist/src/utils/names.d.ts.map +1 -0
package/dist/src/utils/permawebos-bundlers.d.ts +28 -0
package/dist/src/utils/permawebos-bundlers.d.ts.map +1 -0
package/dist/src/utils/signer.d.ts +4 -6
package/dist/src/utils/signer.d.ts.map +1 -1
package/dist/src/utils/uploader.d.ts +5 -7
package/dist/src/utils/uploader.d.ts.map +1 -1
package/dist/src/utils/validators.d.ts +13 -20
package/dist/src/utils/validators.d.ts.map +1 -1
package/dist/src/workflows/upload-workflow.d.ts +3 -4
package/dist/src/workflows/upload-workflow.d.ts.map +1 -1
package/dist/tests/mocks/{turbo-handlers.d.ts → legacy-handlers.d.ts} +12 -27
package/dist/tests/mocks/legacy-handlers.d.ts.map +1 -0
package/dist/tests/setup.d.ts +2 -2
package/dist/tests/setup.d.ts.map +1 -1
package/dist/tests/types/payment-service.d.ts +2 -2
package/dist/tests/types/payment-service.d.ts.map +1 -1
package/dist/tests/types/upload-service.d.ts +1 -1
package/dist/tests/types/upload-service.d.ts.map +1 -1
package/dist/utils/config-resolver.js +4 -1
package/dist/utils/config-resolver.js.map +1 -1
package/dist/utils/constants.js +1 -3
package/dist/utils/constants.js.map +1 -1
package/dist/utils/hyperbeam-uploaders-cli.js +32 -0
package/dist/utils/hyperbeam-uploaders-cli.js.map +1 -0
package/dist/utils/names.js +157 -0
package/dist/utils/names.js.map +1 -0
package/dist/utils/permawebos-bundlers.js +120 -0
package/dist/utils/permawebos-bundlers.js.map +1 -0
package/dist/utils/signer.js +3 -2
package/dist/utils/signer.js.map +1 -1
package/dist/utils/uploader.js +1 -1
package/dist/utils/validators.js +3 -39
package/dist/utils/validators.js.map +1 -1
package/dist/workflows/upload-workflow.js +5 -6
package/dist/workflows/upload-workflow.js.map +1 -1
package/package.json +5 -5
package/dist/chunks/upload-workflow-BnN8mhkm.js +0 -1195
package/dist/chunks/upload-workflow-BnN8mhkm.js.map +0 -1
package/dist/chunks/uploader-CC-qBdlV.js.map +0 -1
package/dist/prompts/arns.js +0 -89
package/dist/prompts/arns.js.map +0 -1
package/dist/src/prompts/arns.d.ts +0 -13
package/dist/src/prompts/arns.d.ts.map +0 -1
package/dist/tests/mocks/turbo-handlers.d.ts.map +0 -1

package/dist/chunks/upload-workflow-f3hExxtV.js ADDED Viewed

@@ -0,0 +1,620 @@
+import { createHash, randomInt } from 'node:crypto';
+import ora from 'ora';
+import { l as loadCache, u as uploadFile, c as cleanupCache, s as saveCache, a as uploadFolder } from './uploader-Bz9jraY2.js';
+import { c as chalk } from './chalk-BP_cCc9v.js';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { Readable } from 'node:stream';
+import { createDataItemSigner, message } from '@permaweb/aoconnect';
+import { discoverHyperbeamAoBundlerProfile, HYPERBEAM_DEFAULT_LEDGER_ID, HYPERBEAM_DEFAULT_LEDGER_ROUTE, HyperbalanceClient, AoTokenTransferAdapter, waitForAoAssignmentSlot, DEFAULT_AO_TOKEN_ID } from '@permaweb/hyperbalance';
+import { createSigner } from '../utils/signer.js';
+import { expandPath } from '../utils/path.js';
+import { fetchActivePermawebOSBundlers } from '../utils/permawebos-bundlers.js';
+const require$2 = createRequire(import.meta.url);
+const { ArweaveSigner, DataItem: DataItem$1, createData: createData$1 } = require$2("@dha-team/arbundles");
+const AO_BASE_UNITS = 1000000000000n;
+const ARWEAVE_GATEWAY = "https://arweave.net";
+async function readableToBuffer$1(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+async function streamToBuffer$1(stream) {
+  if (Buffer.isBuffer(stream)) {
+    return stream;
+  }
+  if (stream instanceof Uint8Array) {
+    return Buffer.from(stream);
+  }
+  if (stream instanceof Readable) {
+    return readableToBuffer$1(stream);
+  }
+  if (stream && typeof stream.getReader === "function") {
+    return readableToBuffer$1(Readable.fromWeb(stream));
+  }
+  throw new Error("Unsupported upload stream type");
+}
+function toBase64Url$1(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return Buffer.from(value).toString("base64url");
+}
+function normalizeUploadUrl(base, uploadPath) {
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  const cleanPath = uploadPath.startsWith("/") ? uploadPath.slice(1) : uploadPath;
+  return new URL(cleanPath, normalizedBase).toString();
+}
+function arweaveAddressFromJwk(jwk) {
+  if (typeof jwk.n !== "string") {
+    throw new TypeError('Arweave JWK is missing modulus field "n"');
+  }
+  return createHash("sha256").update(Buffer.from(jwk.n, "base64url")).digest("base64url");
+}
+function parseHyperbeamFundAmount(value) {
+  if (!/^[1-9]\d*$/.test(value)) {
+    throw new Error("--hyperbeam-fund-amount must be a positive integer in token base units");
+  }
+  return BigInt(value);
+}
+function formatAoAmount(amount) {
+  const whole = amount / AO_BASE_UNITS;
+  const fraction = amount % AO_BASE_UNITS;
+  if (fraction === 0n) {
+    return `${whole.toString()} AO`;
+  }
+  return `${whole.toString()}.${fraction.toString().padStart(12, "0").replaceAll(/0+$/g, "")} AO`;
+}
+function responsePreview$1(body) {
+  const preview = body.replaceAll(/\s+/g, " ").trim();
+  if (!preview) {
+    return void 0;
+  }
+  if (/^(<!doctype html\b|<html\b)/i.test(preview)) {
+    return "HTML error response";
+  }
+  return preview.slice(0, 300);
+}
+async function ensureHyperbeamCredit(options, profile) {
+  const jwk = JSON.parse(Buffer.from(options.deployKey, "base64").toString("utf8"));
+  const recipient = arweaveAddressFromJwk(jwk);
+  const signer = createDataItemSigner(jwk);
+  const client = new HyperbalanceClient({ nodeUrl: options.uploader });
+  const adapter = new AoTokenTransferAdapter({
+    async inferSender() {
+      return recipient;
+    },
+    async message(input) {
+      return message({
+        data: input.data ?? "",
+        process: input.process,
+        signer,
+        tags: input.tags
+      });
+    },
+    async waitForAssignmentSlot(messageId, context) {
+      return waitForAoAssignmentSlot({
+        messageId,
+        pollMs: options.aoPollMs,
+        processId: context.processId,
+        stateUrl: options.aoStateUrl,
+        timeoutMs: options.aoTimeoutMs
+      });
+    }
+  });
+  return client.ensureCreditAuto({
+    ledgerId: options.ledgerId,
+    minimumBalance: options.minimumBalance,
+    profile,
+    recipient,
+    tokenId: options.tokenId ?? DEFAULT_AO_TOKEN_ID,
+    transferAdapter: adapter
+  });
+}
+async function autoFundQuotedHyperbeamLedger(options) {
+  const profile = await discoverHyperbeamAoBundlerProfile({
+    ledgerId: options.ledgerId,
+    nodeUrl: options.uploader,
+    tokenId: options.tokenId
+  });
+  const client = new HyperbalanceClient({ nodeUrl: options.uploader });
+  let { ledgerId } = options;
+  let { minimumBalance } = options;
+  let { tokenId } = options;
+  if (minimumBalance === void 0) {
+    const quote = await client.quoteAuto({
+      action: options.quoteAction ?? "hyperbeam-upload",
+      params: { bytes: options.signedBytes },
+      profile
+    });
+    minimumBalance = quote.amount;
+    ledgerId ??= quote.ledgerId;
+    tokenId ??= quote.tokenId;
+  }
+  return ensureHyperbeamCredit(
+    {
+      aoPollMs: options.aoPollMs,
+      aoStateUrl: options.aoStateUrl,
+      aoTimeoutMs: options.aoTimeoutMs,
+      deployKey: options.deployKey,
+      ledgerId,
+      minimumBalance,
+      tokenId,
+      uploader: options.uploader
+    },
+    profile
+  );
+}
+async function quoteHyperbeamUpload(options) {
+  const profile = await discoverHyperbeamAoBundlerProfile({
+    ledgerId: options.ledgerId,
+    nodeUrl: options.uploader,
+    tokenId: options.tokenId
+  });
+  const quote = await new HyperbalanceClient({ nodeUrl: options.uploader }).quoteAuto({
+    action: options.quoteAction ?? "hyperbeam-upload",
+    params: { bytes: options.signedBytes },
+    profile
+  });
+  return { amount: quote.amount, ledgerId: quote.ledgerId, tokenId: quote.tokenId };
+}
+function hyperbeamBundlerLink(uploader, id, isManifest = false) {
+  const normalizedBase = uploader.endsWith("/") ? uploader : `${uploader}/`;
+  return new URL(`${encodeURIComponent(id)}${isManifest ? "/" : ""}`, normalizedBase).toString();
+}
+async function preflightHyperbeamBundlerArBalance(uploader) {
+  const nodeUrl = uploader.replace(/\/+$/, "");
+  const addressRes = await fetch(`${nodeUrl}/~meta@1.0/info/address`);
+  if (!addressRes.ok) {
+    throw new Error(`HyperBEAM bundler address check failed with HTTP ${addressRes.status}`);
+  }
+  const address = (await addressRes.text()).trim();
+  if (!address) {
+    throw new Error("HyperBEAM bundler address check returned an empty address");
+  }
+  const balanceRes = await fetch(`${ARWEAVE_GATEWAY}/wallet/${encodeURIComponent(address)}/balance`);
+  if (!balanceRes.ok) {
+    throw new Error(`HyperBEAM bundler AR balance check failed with HTTP ${balanceRes.status}`);
+  }
+  const balance = (await balanceRes.text()).trim();
+  if (!/^\d+$/.test(balance)) {
+    throw new Error("HyperBEAM bundler AR balance check returned an invalid balance");
+  }
+  if (BigInt(balance) === 0n) {
+    throw new Error(
+      `HyperBEAM bundler wallet ${address} has 0 AR; upload aborted because the node cannot seed data to Arweave.`
+    );
+  }
+}
+function responseId(headers, body) {
+  const headerId = headers.get("id");
+  if (headerId) {
+    return headerId;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.id || parsed.body?.id;
+  } catch {
+    return void 0;
+  }
+}
+async function postHyperbeamDataItem(uploadUrl, raw, localId) {
+  const res = await fetch(uploadUrl, {
+    body: raw,
+    headers: {
+      accept: "application/json, text/plain, */*",
+      "content-type": "application/octet-stream"
+    },
+    method: "POST"
+  });
+  const body = await res.text();
+  if (!res.ok) {
+    const preview = responsePreview$1(body);
+    const itemContext = localId ? ` for local data item ${localId}` : "";
+    throw new Error(
+      `HyperBEAM bundler upload failed${itemContext} with HTTP ${res.status}${preview ? `: ${preview}` : ""}`
+    );
+  }
+  return { body, id: responseId(res.headers, body) };
+}
+function cleanAutoFundErrorMessage(message) {
+  const jsonStart = message.indexOf("{");
+  if (jsonStart >= 0) {
+    try {
+      const parsed = JSON.parse(message.slice(jsonStart));
+      if (parsed.error) {
+        return parsed.error.replace(/^Error:\s*/, "");
+      }
+    } catch {
+    }
+  }
+  return message;
+}
+function autoFundFailureNote(message) {
+  if (/rate limit exceeded/i.test(message)) {
+    return "AO token transfer was rate limited. Check that the wallet has enough spendable AO before retrying auto-fund.";
+  }
+  return "Check the wallet or node ledger before retrying auto-fund; the AO transfer may already have been submitted.";
+}
+function autoFundUnavailableMessage(message) {
+  return [
+    "HyperBEAM auto-fund was requested, but this node is not hyperbalance-compatible for this upload.",
+    `Auto-fund compatibility check failed: ${message}`,
+    "Attempted direct upload instead."
+  ].join("\n");
+}
+class HyperbeamBundlerClient {
+  autoFund;
+  quote;
+  seedPreflight;
+  signer;
+  uploader;
+  uploadUrl;
+  constructor({ autoFund, deployKey, quote, uploadPath, uploader }) {
+    const jwk = JSON.parse(Buffer.from(deployKey, "base64").toString("utf8"));
+    this.autoFund = autoFund;
+    this.quote = quote ?? { uploader };
+    this.signer = new ArweaveSigner(jwk);
+    this.uploader = uploader;
+    this.uploadUrl = normalizeUploadUrl(uploader, uploadPath);
+  }
+  async uploadFile(args) {
+    const data = args.file ? typeof args.file === "string" ? fs.readFileSync(args.file) : args.file : await streamToBuffer$1(args.fileStreamFactory?.() ?? Readable.from([]));
+    const tags = args.dataItemOpts?.tags ?? [];
+    const item = createData$1(data, this.signer, { tags });
+    await item.sign(this.signer);
+    const raw = Buffer.from(item.getRaw());
+    const localId = item.id || toBase64Url$1(new DataItem$1(raw).id);
+    const size = { payloadBytes: data.length, signedBytes: raw.length };
+    let autoFundUnavailable;
+    let autoFundQuote;
+    let cost;
+    if (this.autoFund) {
+      try {
+        autoFundQuote = await quoteHyperbeamUpload({ ...this.quote, signedBytes: raw.length });
+        cost = { amount: autoFundQuote.amount, token: "AO" };
+      } catch (error) {
+        autoFundUnavailable = cleanAutoFundErrorMessage(
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    } else {
+      try {
+        const quote = await quoteHyperbeamUpload({ ...this.quote, signedBytes: raw.length });
+        cost = { amount: quote.amount, token: "AO" };
+      } catch {
+        cost = void 0;
+      }
+    }
+    this.seedPreflight ??= preflightHyperbeamBundlerArBalance(this.uploader);
+    await this.seedPreflight;
+    if (this.autoFund && autoFundQuote) {
+      try {
+        await autoFundQuotedHyperbeamLedger({
+          ...this.autoFund,
+          ledgerId: this.autoFund.ledgerId ?? autoFundQuote.ledgerId,
+          minimumBalance: this.autoFund.minimumBalance ?? autoFundQuote.amount,
+          signedBytes: raw.length,
+          tokenId: this.autoFund.tokenId ?? autoFundQuote.tokenId
+        });
+      } catch (error) {
+        const message = cleanAutoFundErrorMessage(
+          error instanceof Error ? error.message : String(error)
+        );
+        throw new Error(
+          [
+            `HyperBEAM auto-fund failed: ${message}`,
+            `Required upload credit: ${formatAoAmount(cost?.amount ?? autoFundQuote.amount)}`,
+            autoFundFailureNote(message),
+            await this.paymentHint(false)
+          ].filter(Boolean).join("\n\n")
+        );
+      }
+    }
+    let posted;
+    try {
+      posted = await postHyperbeamDataItem(this.uploadUrl, raw, localId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const needsPayment = message.includes("HTTP 402");
+      const paymentHint = needsPayment ? await this.paymentHint(autoFundUnavailable ? false : void 0) : void 0;
+      throw new Error(
+        [
+          message,
+          needsPayment && autoFundUnavailable ? autoFundUnavailableMessage(autoFundUnavailable) : void 0,
+          paymentHint
+        ].filter(Boolean).join("\n\n")
+      );
+    }
+    return { cost, id: posted.id || localId, size };
+  }
+  async paymentHint(includeAutoFundInstruction = true) {
+    try {
+      return hyperbeamAoFundingHint(
+        await discoverHyperbeamAoBundlerProfile({ nodeUrl: this.uploader }),
+        { includeAutoFundInstruction }
+      );
+    } catch {
+      try {
+        const operator = await fetch(
+          `${this.uploader.replace(/\/+$/, "")}/~meta@1.0/info/address`
+        ).then((res) => res.ok ? res.text() : void 0);
+        if (!operator?.trim()) return void 0;
+        return [
+          "The HyperBEAM node requires AO in its local ledger:",
+          `- AO: send funds to ${operator.trim()}. Local ledger: ${HYPERBEAM_DEFAULT_LEDGER_ID} at ${HYPERBEAM_DEFAULT_LEDGER_ROUTE}.`,
+          includeAutoFundInstruction ? "Use --hyperbeam-auto-fund to transfer AO and import the credit automatically before upload." : void 0
+        ].filter(Boolean).join("\n");
+      } catch {
+        return void 0;
+      }
+    }
+  }
+}
+function hyperbeamAoFundingHint(profile, options = {}) {
+  const lines = profile.tokens.map((token) => {
+    const depositAddress = token.depositAddress ?? profile.node?.operator;
+    if (!depositAddress) return;
+    const label = token.ticker === "AO" ? "AO" : token.ticker ? `${token.ticker} (${token.id})` : token.id;
+    const ledger = token.ledgerId ? profile.ledgers.find((candidate) => candidate.id === token.ledgerId) : void 0;
+    const ledgerInfo = ledger ? ` Local ledger: ${ledger.id}${ledger.route ? ` at ${ledger.route}` : ""}.` : "";
+    return `- ${label}: send funds to ${depositAddress}.${ledgerInfo}`;
+  }).filter(Boolean);
+  if (lines.length === 0) return void 0;
+  return [
+    "The HyperBEAM node requires AO in its local ledger:",
+    ...lines,
+    options.includeAutoFundInstruction === false ? void 0 : "Use --hyperbeam-auto-fund to transfer AO and import the credit automatically before upload."
+  ].filter(Boolean).join("\n");
+}
+const require$1 = createRequire(import.meta.url);
+const { DataItem, createData } = require$1("@dha-team/arbundles");
+async function readableToBuffer(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+async function streamToBuffer(stream) {
+  if (Buffer.isBuffer(stream)) {
+    return stream;
+  }
+  if (stream instanceof Uint8Array) {
+    return Buffer.from(stream);
+  }
+  if (stream instanceof Readable) {
+    return readableToBuffer(stream);
+  }
+  if (stream && typeof stream.getReader === "function") {
+    return readableToBuffer(Readable.fromWeb(stream));
+  }
+  throw new Error("Unsupported upload stream type");
+}
+function toBase64Url(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return Buffer.from(value).toString("base64url");
+}
+function legacyUploadUrl(base, token) {
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  return new URL(`v1/tx/${token}`, normalizedBase).toString();
+}
+function responsePreview(body) {
+  const preview = body.replaceAll(/\s+/g, " ").trim();
+  if (!preview) {
+    return void 0;
+  }
+  return preview.slice(0, 300);
+}
+class LegacyBundlerClient {
+  signer;
+  token;
+  uploadUrl;
+  constructor({ deployKey, sigType, uploader }) {
+    const { signer, token } = createSigner(sigType, deployKey);
+    this.signer = signer;
+    this.token = token;
+    this.uploadUrl = legacyUploadUrl(uploader, token);
+  }
+  /**
+   * Sign and post one ANS-104 data item.
+   *
+   * @param args - Upload payload and data item tags.
+   * @returns The upload response with the data item ID.
+   */
+  async uploadFile(args) {
+    const data = args.file ? typeof args.file === "string" ? fs.readFileSync(args.file) : args.file : await streamToBuffer(args.fileStreamFactory?.() ?? Readable.from([]));
+    const tags = args.dataItemOpts?.tags ?? [];
+    const item = createData(data, this.signer, { tags });
+    await item.sign(this.signer);
+    const raw = Buffer.from(item.getRaw());
+    const localId = item.id || toBase64Url(new DataItem(raw).id);
+    const size = { payloadBytes: data.length, signedBytes: raw.length };
+    const response = await fetch(this.uploadUrl, {
+      body: raw,
+      headers: {
+        "content-length": String(raw.length),
+        "content-type": "application/octet-stream"
+      },
+      method: "POST"
+    });
+    const body = await response.text();
+    if (!response.ok) {
+      const preview = responsePreview(body);
+      throw new Error(
+        `Legacy bundler upload failed with HTTP ${response.status}${preview ? `: ${preview}` : ""}`
+      );
+    }
+    let id;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        id = typeof parsed.id === "string" ? parsed.id : void 0;
+      } catch {
+        id = void 0;
+      }
+    }
+    return { id: id ?? localId, size };
+  }
+}
+function randomizedUploaders(uploaders) {
+  const candidates = [...uploaders];
+  for (let index = candidates.length - 1; index > 0; index -= 1) {
+    const swapIndex = randomInt(index + 1);
+    const current = candidates[index];
+    const replacement = candidates[swapIndex];
+    candidates[index] = replacement;
+    candidates[swapIndex] = current;
+  }
+  return candidates;
+}
+async function discoverUsableHyperbeamUploader(spinner) {
+  spinner.start("Discovering active HyperBEAM uploaders");
+  const uploaders = randomizedUploaders(await fetchActivePermawebOSBundlers());
+  if (uploaders.length === 0) {
+    spinner.fail("No active HyperBEAM uploaders found");
+    throw new Error("No active HyperBEAM uploaders found");
+  }
+  const failures = [];
+  for (const uploader of uploaders) {
+    try {
+      await preflightHyperbeamBundlerArBalance(uploader.url);
+      spinner.succeed(`Selected HyperBEAM bundler (${chalk.cyan(uploader.url)})`);
+      return uploader.url;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${uploader.url}: ${message}`);
+    }
+  }
+  spinner.fail("No active HyperBEAM uploaders with spendable AR found");
+  throw new Error(
+    [
+      "No active HyperBEAM uploaders with spendable AR found.",
+      failures.length > 0 ? failures.join("\n") : void 0
+    ].filter(Boolean).join("\n")
+  );
+}
+async function runUploadWorkflow(deployKey, config, io) {
+  const spinner = ora();
+  const uploaderType = config["uploader-type"] ?? "legacy";
+  let uploadClient;
+  let effectiveUploader;
+  if (uploaderType === "hyperbeam") {
+    if (config["sig-type"] !== "arweave") {
+      io.error("HyperBEAM uploads require --sig-type arweave");
+    }
+    effectiveUploader = config.uploader ?? await discoverUsableHyperbeamUploader(spinner);
+    let autoFund;
+    if (config["hyperbeam-auto-fund"]) {
+      autoFund = {
+        deployKey,
+        uploader: effectiveUploader
+      };
+      if (config["hyperbeam-ao-state-url"]) autoFund.aoStateUrl = config["hyperbeam-ao-state-url"];
+      if (config["hyperbeam-ledger-id"]) autoFund.ledgerId = config["hyperbeam-ledger-id"];
+      if (config["hyperbeam-token-id"]) autoFund.tokenId = config["hyperbeam-token-id"];
+      if (config["hyperbeam-fund-amount"]) {
+        autoFund.minimumBalance = parseHyperbeamFundAmount(config["hyperbeam-fund-amount"]);
+      }
+    }
+    spinner.start("Initializing HyperBEAM bundler");
+    uploadClient = new HyperbeamBundlerClient({
+      autoFund,
+      deployKey,
+      quote: {
+        ledgerId: config["hyperbeam-ledger-id"],
+        tokenId: config["hyperbeam-token-id"],
+        uploader: effectiveUploader
+      },
+      uploadPath: config["hyperbeam-upload-path"] ?? "/~bundler@1.0/item?codec-device=ans104@1.0",
+      uploader: effectiveUploader
+    });
+    spinner.succeed(`HyperBEAM bundler initialized (${chalk.cyan(effectiveUploader)})`);
+  } else {
+    effectiveUploader = config.uploader ?? "https://up.arweave.net";
+    spinner.start("Initializing legacy bundler");
+    uploadClient = new LegacyBundlerClient({
+      deployKey,
+      sigType: config["sig-type"],
+      uploader: effectiveUploader
+    });
+    spinner.succeed("Legacy bundler initialized");
+  }
+  let txOrManifestId;
+  let cost;
+  let size;
+  try {
+    if (config["deploy-file"]) {
+      const filePath = expandPath(config["deploy-file"]);
+      spinner.start(`Uploading file ${chalk.yellow(config["deploy-file"])}`);
+      let cache = config["dedupe-cache-max-entries"] > 0 ? loadCache() : {};
+      const uploadResult = await uploadFile(uploadClient, filePath, { cache });
+      if (!uploadResult.transactionId) {
+        spinner.fail("File upload failed: no transaction ID returned");
+        io.error("File upload failed: no transaction ID returned");
+      }
+      txOrManifestId = uploadResult.transactionId;
+      cost = uploadResult.cost;
+      size = uploadResult.size;
+      if (uploadResult.updatedCache && config["dedupe-cache-max-entries"] > 0) {
+        cache = cleanupCache(uploadResult.updatedCache, config["dedupe-cache-max-entries"]);
+        saveCache(cache);
+      }
+      if (uploadResult.cacheHit) {
+        spinner.succeed(`File cache hit - reusing transaction ${chalk.green(txOrManifestId)}`);
+      } else {
+        const cacheMsg = config["dedupe-cache-max-entries"] > 0 ? chalk.gray("(cached for future uploads)") : "";
+        spinner.succeed(`File uploaded: ${chalk.green(txOrManifestId)} ${cacheMsg}`.trim());
+      }
+    } else {
+      const folderPath = expandPath(config["deploy-folder"]);
+      spinner.start(`Uploading folder ${chalk.yellow(config["deploy-folder"])}`);
+      let cache = config["dedupe-cache-max-entries"] > 0 ? loadCache() : {};
+      const uploadResult = await uploadFolder(uploadClient, folderPath, {
+        cache,
+        concurrency: config["hyperbeam-auto-fund"] ? 1 : void 0,
+        omitManifestDeviceTag: uploaderType === "hyperbeam",
+        throwOnFailure: true
+      });
+      if (!uploadResult.transactionId) {
+        spinner.fail("Folder upload failed: no transaction ID returned");
+        io.error("Folder upload failed: no transaction ID returned");
+      }
+      txOrManifestId = uploadResult.transactionId;
+      cost = uploadResult.cost;
+      size = uploadResult.size;
+      if (uploadResult.updatedCache && config["dedupe-cache-max-entries"] > 0) {
+        cache = cleanupCache(uploadResult.updatedCache, config["dedupe-cache-max-entries"]);
+        saveCache(cache);
+      }
+      const { cacheHits, totalFiles, uploaded } = uploadResult;
+      const statsMsg = cacheHits > 0 ? chalk.gray(` (${cacheHits}/${totalFiles} files cached, ${uploaded} uploaded)`) : "";
+      if (uploadResult.cacheHit) {
+        spinner.succeed(`All ${totalFiles} files cached - manifest: ${chalk.green(txOrManifestId)}`);
+      } else {
+        const cacheMsg = config["dedupe-cache-max-entries"] > 0 ? chalk.gray(" (files cached for future uploads)") : "";
+        spinner.succeed(`Folder uploaded: ${chalk.green(txOrManifestId)}${statsMsg}${cacheMsg}`);
+      }
+    }
+  } catch (uploadError) {
+    spinner.fail("Upload failed");
+    const errorMessage = uploadError instanceof Error ? uploadError.message : String(uploadError);
+    io.error(`Upload failed: ${errorMessage}`);
+  }
+  return {
+    cost,
+    size,
+    transactionId: txOrManifestId,
+    uploader: effectiveUploader
+  };
+}
+export { hyperbeamBundlerLink as h, runUploadWorkflow as r };
+//# sourceMappingURL=upload-workflow-f3hExxtV.js.map