hyperframes 0.8.183 → 0.8.185

package/dist/render-GQFXJWLV.js

@@ -0,0 +1,1504 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  parseEnumFlag,
+  parseIntFlag,
+  parseNumericFlag
+} from "./chunk-DGECWPTL.js";
+import {
+  colorStatus
+} from "./chunk-U7CZBDMV.js";
+import {
+  DEFAULT_MAX_WAIT_MS,
+  DEFAULT_POLL_INTERVAL_MS,
+  PollTimeoutError,
+  createCloudClient,
+  pollUntilTerminal,
+  reportApiError
+} from "./chunk-J36JVBLR.js";
+import {
+  uploadAssetViaDirectUpload,
+  uploadZipViaDirectUpload
+} from "./chunk-5UDRPPN2.js";
+import "./chunk-5UBZPG74.js";
+import {
+  TEXT_FILE_EXTS,
+  assertUnchanged,
+  readChecked,
+  readStaged,
+  rewriteCssUrls,
+  rewriteHtmlAttributes,
+  rewriteStyleBlocks,
+  stagePublishFiles,
+  stagedSize,
+  zipPublishFileMap
+} from "./chunk-XGHHVYC7.js";
+import "./chunk-JQYJXUJW.js";
+import {
+  resolveCloudBaseUrl
+} from "./chunk-HRPWRZGF.js";
+import "./chunk-7KVVNF7B.js";
+import {
+  reportVariableIssues,
+  resolveVariablesArg,
+  validateVariablesAgainstProject
+} from "./chunk-37CNYTQQ.js";
+import {
+  downloadToFile
+} from "./chunk-CZUAX3BV.js";
+import {
+  findFFmpeg,
+  findFFprobe,
+  getFFmpegInstallHint
+} from "./chunk-K2ZKXTVL.js";
+import {
+  resolveProject
+} from "./chunk-5GUKZRQN.js";
+import {
+  errorBox,
+  formatBytes,
+  formatDuration
+} from "./chunk-K2FLNJVB.js";
+import "./chunk-442JNXRM.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-WQLKDL35.js";
+import "./chunk-H5SM5PJI.js";
+import "./chunk-VWG7OQKU.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-I3IH5MV5.js";
+import "./chunk-IZCW2NKT.js";
+import {
+  parseAnimatedGifMetadata
+} from "./chunk-KROXPHXX.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-Q47FAYYK.js";
+import "./chunk-3NPOFC43.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-UJKQWGFF.js";
+import "./chunk-B2A56S5C.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-DYAPHNV6.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-Q447CX26.js";
+import "./chunk-VAS6HQX3.js";
+import {
+  cleanAssetUrl,
+  isRemoteOrInlineUrl,
+  resolveLocalAssetCandidates
+} from "./chunk-6BNTGNGD.js";
+import "./chunk-RUOG4VB7.js";
+import "./chunk-MMQ52NIZ.js";
+import {
+  readAuthoredDurationSeconds,
+  readMediaOffsetSeconds,
+  readPlaybackRate,
+  rewriteAssetPath
+} from "./chunk-BSQ7XANM.js";
+import {
+  parseHTML
+} from "./chunk-SDYDNHEE.js";
+import "./chunk-IXLUTE6N.js";
+import "./chunk-I5JRXMCV.js";
+import "./chunk-W2LGJSEN.js";
+import {
+  withMeta
+} from "./chunk-ISTRDGIX.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-I7QMXZSB.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/cloud/detectAspectRatio.ts
+import { readFileSync } from "fs";
+var RATIO_TOLERANCE = 0.05;
+var SUPPORTED_RATIOS = [
+  { value: "16:9", ratio: 16 / 9 },
+  { value: "9:16", ratio: 9 / 16 },
+  { value: "1:1", ratio: 1 }
+];
+var ROOT_COMPOSITION_DIV_RE = /<div\b[^>]*?\bdata-composition-id\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)[^>]*>/i;
+var DATA_WIDTH_RE = /\bdata-width\s*=\s*(?:"(\d+(?:\.\d+)?)"|'(\d+(?:\.\d+)?)'|(\d+(?:\.\d+)?))(?=\s|>|\/)/i;
+var DATA_HEIGHT_RE = /\bdata-height\s*=\s*(?:"(\d+(?:\.\d+)?)"|'(\d+(?:\.\d+)?)'|(\d+(?:\.\d+)?))(?=\s|>|\/)/i;
+function extractAttributeNumber(tag, re) {
+  const match = tag.match(re);
+  if (!match) return null;
+  const raw = match[1] ?? match[2] ?? match[3];
+  if (raw === void 0) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+function detectAspectRatioFromHtml(entryHtmlPath) {
+  let html;
+  try {
+    html = readFileSync(entryHtmlPath, "utf-8");
+  } catch (err) {
+    return { kind: "read-error", error: normalizeErrorMessage(err) };
+  }
+  return detectAspectRatioFromHtmlString(html);
+}
+function detectAspectRatioFromHtmlString(html) {
+  const tagMatch = html.match(ROOT_COMPOSITION_DIV_RE);
+  if (!tagMatch) return { kind: "no-root-div" };
+  const openTag = tagMatch[0];
+  const width = extractAttributeNumber(openTag, DATA_WIDTH_RE);
+  const height = extractAttributeNumber(openTag, DATA_HEIGHT_RE);
+  if (width === null || height === null) return { kind: "no-dims" };
+  if (width <= 0 || height <= 0) return { kind: "invalid-dims", width, height };
+  const ratio = width / height;
+  for (const candidate of SUPPORTED_RATIOS) {
+    if (Math.abs(ratio - candidate.ratio) <= RATIO_TOLERANCE) {
+      return { kind: "matched", aspectRatio: candidate.value, width, height };
+    }
+  }
+  return { kind: "no-match", width, height, ratio };
+}
+
+// src/cloud/offload.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+import {
+  copyFileSync,
+  createReadStream,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir, tmpdir } from "os";
+import { basename as basename2, dirname, extname, join, posix, relative, resolve } from "path";
+import { promisify } from "util";
+
+// src/cloud/offloadTrim.ts
+import { basename } from "path";
+var TRIM_MARGIN_SECONDS = 0.5;
+var RETIMING_SCRIPT_RE = /data-(?:playback-start|media-start|start|duration|end|playback-rate)|\b(?:dataset|setAttribute|currentTime|playbackRate)\b|\.(?:src|loop)\b/;
+function mediaSources(el) {
+  const own = el.getAttribute("src");
+  const nested = [...el.querySelectorAll("source[src]")].map((s) => s.getAttribute("src"));
+  return [...own ? [own] : [], ...nested];
+}
+function hasTimedAncestor(el) {
+  for (let p = el.parentElement; p; p = p.parentElement) {
+    const get = (name) => p.getAttribute(name);
+    if (readMediaOffsetSeconds(get) > 0) return true;
+    if (p.hasAttribute("data-composition-id") && p.parentElement?.closest("[data-composition-id]")) {
+      return true;
+    }
+  }
+  return false;
+}
+function playedWindow(el) {
+  if (el.hasAttribute("loop") || el.hasAttribute("data-automation") || el.hasAttribute("data-var-src") || hasTimedAncestor(el)) {
+    return null;
+  }
+  const get = (name) => el.getAttribute(name);
+  const start = readMediaOffsetSeconds(get);
+  const duration = readAuthoredDurationSeconds(get, Number(get("data-start") ?? 0));
+  if (duration === null || !(duration > 0)) return null;
+  return { start, end: start + duration * readPlaybackRate(get) };
+}
+function mergeWindows(windows, gridPerSecond) {
+  const down = (t) => Math.floor(t * gridPerSecond) / gridPerSecond;
+  const up = (t) => Math.ceil(t * gridPerSecond) / gridPerSecond;
+  const merged = [];
+  for (const w of [...windows].sort((a, b) => a.start - b.start)) {
+    const start = down(Math.max(0, w.start - TRIM_MARGIN_SECONDS));
+    const end = up(w.end + TRIM_MARGIN_SECONDS);
+    const last = merged.at(-1);
+    if (last && start <= last.end) last.end = Math.max(last.end, end);
+    else merged.push({ start, end });
+  }
+  return merged;
+}
+function shiftMediaStart(el, segments) {
+  const get = (name) => el.getAttribute(name);
+  const start = readMediaOffsetSeconds(get);
+  let offset = 0;
+  for (const segment of segments) {
+    if (start >= segment.start && start < segment.end) {
+      const attr = Number.parseFloat(get("data-playback-start") ?? "") >= 0 ? "data-playback-start" : "data-media-start";
+      el.setAttribute(attr, String(offset + (start - segment.start)));
+      return;
+    }
+    offset += segment.end - segment.start;
+  }
+}
+function planTrim(input) {
+  if (input.mentionedElsewhere || RETIMING_SCRIPT_RE.test(input.scriptCode)) return null;
+  const { document } = parseHTML(input.entryHtml);
+  const uses = [];
+  let sources = 0;
+  for (const el of document.querySelectorAll("video, audio")) {
+    const matching = mediaSources(el).filter((src) => input.resolveKey(src) === input.path);
+    if (matching.length === 0) continue;
+    if (matching.some((src) => src.includes("#"))) return null;
+    uses.push(el);
+    sources += matching.length;
+  }
+  if (uses.length === 0 || input.entryHtml.split(basename(input.path)).length - 1 !== sources) {
+    return null;
+  }
+  const windows = uses.map(playedWindow);
+  if (windows.some((w) => w === null)) return null;
+  const segments = mergeWindows(windows, input.gridPerSecond);
+  for (const el of uses) shiftMediaStart(el, segments);
+  return { segments, html: document.toString() };
+}
+
+// src/cloud/offload.ts
+var execFileAsync = promisify(execFile);
+var OFFLOAD_MIN_BYTES = 5 * 1024 * 1024;
+var MiB = 1024 * 1024;
+var AUDIO_MAX_BYTES = 15e8;
+var ACCEPTED = {
+  ".mp4": { contentType: "video/mp4", maxBytes: 200 * MiB },
+  ".m4v": { contentType: "video/mp4", maxBytes: 200 * MiB },
+  ".mov": { contentType: "video/quicktime", maxBytes: 200 * MiB },
+  ".webm": { contentType: "video/webm", maxBytes: 200 * MiB },
+  ".png": { contentType: "image/png", maxBytes: 200 * MiB },
+  ".jpg": { contentType: "image/jpeg", maxBytes: 200 * MiB },
+  ".jpeg": { contentType: "image/jpeg", maxBytes: 200 * MiB },
+  ".webp": { contentType: "image/webp", maxBytes: 200 * MiB },
+  ".wav": { contentType: "audio/wav", maxBytes: AUDIO_MAX_BYTES },
+  ".mp3": { contentType: "audio/mpeg", maxBytes: AUDIO_MAX_BYTES }
+};
+var VIDEO_EXTS = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".m4v",
+  ".mov",
+  ".webm",
+  ".mkv",
+  ".avi",
+  ".mpg",
+  ".mpeg",
+  ".ts",
+  ".m2ts",
+  ".mts",
+  ".flv",
+  ".wmv",
+  ".ogv",
+  ".3gp"
+]);
+var AUDIO_EXTS = /* @__PURE__ */ new Set([
+  ".wav",
+  ".mp3",
+  ".m4a",
+  ".aac",
+  ".ogg",
+  ".oga",
+  ".opus",
+  ".flac",
+  ".aif",
+  ".aiff",
+  ".wma"
+]);
+var CONVERTIBLE_IMAGE_EXTS = /* @__PURE__ */ new Set([".gif", ".avif", ".bmp", ".tif", ".tiff"]);
+var REENCODE_PRESETS = {
+  video: {
+    ext: ".mp4",
+    contentType: "video/mp4",
+    args: ["-c:v", "libx264", "-preset", "slow", "-crf", "18", "-pix_fmt", "yuv420p"],
+    audio: ["-c:a", "aac", "-b:a", "320k", "-movflags", "+faststart"]
+  },
+  hdrVideo: {
+    ext: ".mp4",
+    contentType: "video/mp4",
+    args: ["-c:v", "libx265", "-preset", "slow", "-crf", "18", "-pix_fmt", "yuv420p10le"],
+    audio: ["-tag:v", "hvc1", "-c:a", "aac", "-b:a", "320k", "-movflags", "+faststart"]
+  },
+  alphaVideo: {
+    ext: ".webm",
+    contentType: "video/webm",
+    args: ["-c:v", "libvpx-vp9", "-crf", "18", "-b:v", "0", "-pix_fmt", "yuva420p"],
+    audio: ["-c:a", "libopus", "-b:a", "256k"]
+  },
+  audio: {
+    ext: ".wav",
+    contentType: "audio/wav",
+    args: ["-vn"],
+    audio: ["-c:a", "pcm_s16le"]
+  },
+  image: {
+    ext: ".png",
+    contentType: "image/png",
+    args: ["-frames:v", "1"],
+    audio: []
+  }
+};
+function defaultOffloadCachePath() {
+  return join(homedir(), ".cache", "hyperframes", "cloud-assets.json");
+}
+function readCache(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeCache(path, cache) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(cache, null, 2));
+  renameSync(tmp, path);
+}
+async function stillServed(entry, fetchImpl) {
+  try {
+    const res = await fetchImpl(entry.url, { method: "HEAD" });
+    return res.ok && Number(res.headers.get("content-length")) === entry.size_bytes;
+  } catch {
+    return false;
+  }
+}
+function mediaKind(path) {
+  const ext = extname(path).toLowerCase();
+  if (VIDEO_EXTS.has(ext)) return "video";
+  if (AUDIO_EXTS.has(ext)) return "audio";
+  if (ACCEPTED[ext] || CONVERTIBLE_IMAGE_EXTS.has(ext)) return "image";
+  return null;
+}
+async function probeVideo(path) {
+  const ffprobe = findFFprobe();
+  if (!ffprobe)
+    throw new Error(`Re-encoding needs ffprobe. Install ffmpeg: ${getFFmpegInstallHint()}`);
+  const { stdout } = await execFileAsync(ffprobe, [
+    "-v",
+    "error",
+    "-select_streams",
+    "v:0",
+    "-show_entries",
+    "stream=codec_name,pix_fmt,color_primaries,color_transfer,color_space:stream_tags",
+    "-of",
+    "json",
+    "--",
+    path
+  ]);
+  const stream = JSON.parse(stdout).streams?.[0] ?? {};
+  const tags = stream.tags ?? {};
+  const alphaTag = Object.entries(tags).some(
+    ([k, v]) => k.toLowerCase() === "alpha_mode" && v === "1"
+  );
+  const transfer = stream.color_transfer;
+  return {
+    // VP9 alpha keeps pix_fmt yuv420p and flags the plane only in the ALPHA_MODE tag.
+    alpha: alphaTag || /^(yuva|rgba|argb|bgra|abgr|gbrap|ya)/.test(String(stream.pix_fmt ?? "")),
+    hdr: transfer === "smpte2084" || transfer === "arib-std-b67",
+    codec: stream.codec_name,
+    color: {
+      primaries: stream.color_primaries,
+      transfer,
+      space: stream.color_space
+    }
+  };
+}
+function alphaDecoderArgs(probe) {
+  if (!probe.alpha) return [];
+  if (probe.codec === "vp9") return ["-c:v", "libvpx-vp9"];
+  if (probe.codec === "vp8") return ["-c:v", "libvpx"];
+  return [];
+}
+function hdrColorArgs({ color }) {
+  return [
+    ...color.primaries ? ["-color_primaries", color.primaries] : [],
+    ...color.transfer ? ["-color_trc", color.transfer] : [],
+    ...color.space ? ["-colorspace", color.space] : []
+  ];
+}
+async function hasAudioStream(ffprobe, path) {
+  const { stdout } = await execFileAsync(ffprobe, [
+    "-v",
+    "error",
+    "-select_streams",
+    "a",
+    "-show_entries",
+    "stream=index",
+    "-of",
+    "csv=p=0",
+    "--",
+    path
+  ]);
+  return stdout.trim() !== "";
+}
+var seconds = (t) => (Math.floor(t * 1e6) / 1e6).toFixed(6);
+async function segmentArgs(sourcePath, decoder, segments, audioOnly) {
+  if (!segments?.length) return [...decoder, "-i", sourcePath];
+  const inputs = segments.flatMap((s) => [
+    ...decoder,
+    "-ss",
+    seconds(s.start),
+    "-t",
+    seconds(s.end - s.start),
+    "-i",
+    sourcePath
+  ]);
+  if (segments.length === 1) return inputs;
+  const audio = audioOnly || await hasAudioStream(findFFprobe(), sourcePath);
+  return [...inputs, ...concatArgs(segments.length, !audioOnly, audio)];
+}
+function concatArgs(count, video, audio) {
+  const pad = (i) => (video ? `[${i}:v]` : "") + (audio ? `[${i}:a]` : "");
+  const pads = Array.from({ length: count }, (_, i) => pad(i)).join("");
+  const flags = `n=${count}:v=${video ? 1 : 0}:a=${audio ? 1 : 0}`;
+  return [
+    "-filter_complex",
+    `${pads}concat=${flags}${video ? "[v]" : ""}${audio ? "[a]" : ""}`,
+    ...video ? ["-map", "[v]"] : [],
+    ...audio ? ["-map", "[a]"] : []
+  ];
+}
+async function ffmpegReencode(sourcePath, presetName, segments) {
+  const ffmpeg = findFFmpeg();
+  if (!ffmpeg) throw new Error(`Re-encoding needs ffmpeg. Install it: ${getFFmpegInstallHint()}`);
+  const preset = REENCODE_PRESETS[presetName];
+  const probe = preset.contentType.startsWith("video/") ? await probeVideo(sourcePath) : void 0;
+  const decoder = probe ? alphaDecoderArgs(probe) : [];
+  const color = presetName === "hdrVideo" && probe ? hdrColorArgs(probe) : [];
+  const workDir = mkdtempSync(join(tmpdir(), "hf-offload-"));
+  const outPath = join(workDir, `${basename2(sourcePath, extname(sourcePath))}${preset.ext}`);
+  try {
+    await execFileAsync(
+      ffmpeg,
+      [
+        "-v",
+        "error",
+        "-y",
+        ...await segmentArgs(sourcePath, decoder, segments, presetName === "audio"),
+        ...preset.args,
+        ...color,
+        ...preset.audio,
+        outPath
+      ],
+      { maxBuffer: 16 * MiB }
+    );
+    return {
+      bytes: readChecked(outPath, ({ size }) => assertFitsAsset(sourcePath, outPath, size)),
+      filename: basename2(outPath),
+      contentType: preset.contentType
+    };
+  } finally {
+    rmSync(workDir, { recursive: true, force: true });
+  }
+}
+async function choosePreset(sourcePath, kind) {
+  if (kind === "audio") return "audio";
+  if (kind === "image") return await isAnimatedImage(sourcePath) ? null : "image";
+  const probe = await probeVideo(sourcePath);
+  return probe.alpha ? "alphaVideo" : probe.hdr ? "hdrVideo" : "video";
+}
+async function isAnimatedImage(path) {
+  if (extname(path).toLowerCase() === ".gif") {
+    return parseAnimatedGifMetadata(readFileSync2(path))?.animated ?? true;
+  }
+  const ffprobe = findFFprobe();
+  if (!ffprobe) return true;
+  try {
+    const { stdout } = await execFileAsync(ffprobe, [
+      "-v",
+      "error",
+      "-show_entries",
+      "stream=nb_frames",
+      "-of",
+      "csv=p=0",
+      "--",
+      path
+    ]);
+    return stdout.split("\n").some((line) => Number(line) > 1);
+  } catch {
+    return true;
+  }
+}
+async function trimGrid(sourcePath, kind) {
+  if (kind === "audio") return 1e3;
+  if (kind !== "video") return null;
+  const ffprobe = findFFprobe();
+  if (!ffprobe) return null;
+  const { stdout } = await execFileAsync(ffprobe, [
+    "-v",
+    "error",
+    "-select_streams",
+    "v:0",
+    "-show_entries",
+    "stream=r_frame_rate,avg_frame_rate",
+    "-of",
+    "csv=p=0",
+    "--",
+    sourcePath
+  ]);
+  const rate = (fraction) => {
+    const [num, den] = (fraction ?? "").split("/").map(Number);
+    return num && den ? num / den : NaN;
+  };
+  const [real, average] = stdout.trim().split(",");
+  const fps = rate(real);
+  return Number.isFinite(fps) && Math.abs(fps - rate(average)) < 0.01 ? fps : null;
+}
+var ffmpegReencoder = { choose: choosePreset, trimGrid, run: ffmpegReencode };
+async function stagedSha256(file) {
+  if (Buffer.isBuffer(file)) return createHash("sha256").update(file).digest("hex");
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(file.absPath)) hash.update(chunk);
+  assertUnchanged(file);
+  return hash.digest("hex");
+}
+function snapshotPath(path, file, tempFiles) {
+  return Buffer.isBuffer(file) ? stagedCopy(path, file, tempFiles) : file.absPath;
+}
+function stagedCopy(path, file, tempFiles) {
+  const dir = mkdtempSync(join(tmpdir(), "hf-offload-src-"));
+  tempFiles.push(dir);
+  const copy = join(dir, basename2(path));
+  if (Buffer.isBuffer(file)) writeFileSync(copy, file);
+  else {
+    copyFileSync(file.absPath, copy);
+    assertUnchanged(file);
+  }
+  return copy;
+}
+function textOf(path, file) {
+  return TEXT_FILE_EXTS.test(path) && Buffer.isBuffer(file) ? file.toString("utf-8") : void 0;
+}
+function scriptCode(fileMap) {
+  const parts = [];
+  for (const [path, content] of fileMap) {
+    const text = textOf(path, content);
+    if (text === void 0) continue;
+    if (/\.html?$/i.test(path)) {
+      for (const script of parseHTML(text).document.querySelectorAll("script:not([src])")) {
+        parts.push(script.textContent ?? "");
+      }
+    } else if (/\.(m?js|cjs|json)$/i.test(path)) parts.push(text);
+  }
+  return parts.join("\n");
+}
+function assertFitsAsset(path, filename, size) {
+  const maxBytes = ACCEPTED[extname(filename).toLowerCase()]?.maxBytes ?? 0;
+  if (size > maxBytes) {
+    throw new Error(
+      `${path} is ${formatBytes(size)} after re-encoding at visually lossless quality, over the ${formatBytes(maxBytes)} a HeyGen asset can hold.`
+    );
+  }
+}
+async function planFile(ctx, path, file) {
+  const kind = mediaKind(path);
+  const size = stagedSize(file);
+  if (!kind || size < OFFLOAD_MIN_BYTES) return null;
+  const sha256 = await stagedSha256(file);
+  const keyFor = (variant2) => `${ctx.opts.apiBaseUrl} ${sha256} ${variant2}`;
+  const accepted = ACCEPTED[extname(path).toLowerCase()];
+  if (accepted && size <= accepted.maxBytes) {
+    return { key: keyFor("as-is"), sourcePath: "", contentType: accepted.contentType };
+  }
+  const sourcePath = snapshotPath(path, file, ctx.tempFiles);
+  const preset = await ctx.reencoder.choose(sourcePath, kind);
+  if (!preset) return null;
+  const segments = kind === "image" ? null : await planFileTrim(ctx, path, sourcePath, kind);
+  const variant = JSON.stringify([REENCODE_PRESETS[preset], segments]);
+  return { key: keyFor(variant), preset, sourcePath, segments: segments ?? void 0 };
+}
+async function planFileTrim(ctx, path, sourcePath, kind) {
+  const entryPath = ctx.opts.entryPath ?? "index.html";
+  const entryHtml = textOf(entryPath, ctx.fileMap.get(entryPath));
+  const gridPerSecond = entryHtml ? await ctx.reencoder.trimGrid?.(sourcePath, kind) : null;
+  if (!entryHtml || !gridPerSecond) return null;
+  const name = basename2(path);
+  const plan = planTrim({
+    entryHtml,
+    path,
+    gridPerSecond,
+    resolveKey: (raw) => htmlSrcKey(ctx.absDir, entryPath, raw, ctx.fileMap),
+    mentionedElsewhere: [...ctx.fileMap].some(
+      ([other, content]) => other !== entryPath && other !== path && !!textOf(other, content)?.includes(name)
+    ),
+    scriptCode: scriptCode(ctx.fileMap)
+  });
+  if (!plan) return null;
+  ctx.fileMap.set(entryPath, Buffer.from(plan.html, "utf-8"));
+  return plan.segments;
+}
+async function offloadFile(ctx, path, file) {
+  const plan = await planFile(ctx, path, file);
+  if (!plan) return null;
+  const item = {
+    path,
+    size_bytes: stagedSize(file),
+    action: plan.preset ? "reencode" : "upload",
+    ...plan.segments && {
+      trimmed_to_seconds: plan.segments.reduce((sum, s) => sum + s.end - s.start, 0)
+    }
+  };
+  const hit = ctx.cache[plan.key];
+  if (hit && (!ctx.opts.upload || await stillServed(hit, ctx.fetchImpl))) {
+    return { ...item, action: "cached", url: hit.url };
+  }
+  if (!ctx.opts.upload) return item;
+  return { ...item, url: await uploadPlanned(ctx, ctx.opts.upload, path, file, plan) };
+}
+async function uploadPlanned(ctx, upload, path, staged, plan) {
+  const filename = basename2(path);
+  const file = plan.preset ? await ctx.reencoder.run(plan.sourcePath, plan.preset, plan.segments) : Buffer.isBuffer(staged) ? { bytes: staged, filename, contentType: plan.contentType } : { path: staged.absPath, size: staged.size, filename, contentType: plan.contentType };
+  if (plan.preset && !Buffer.isBuffer(staged)) assertUnchanged(staged);
+  const size = "bytes" in file ? file.bytes.byteLength : file.size;
+  assertFitsAsset(path, file.filename, size);
+  const asset = await upload(file);
+  if (!Buffer.isBuffer(staged)) assertUnchanged(staged);
+  ctx.cache[plan.key] = {
+    asset_id: asset.asset_id,
+    url: asset.url,
+    size_bytes: size
+  };
+  writeCache(ctx.cachePath, ctx.cache);
+  return asset.url;
+}
+var GIF_PREFIX = "_animated_gif";
+async function prepareEntryGifs(ctx, fileMap) {
+  const entryPath = ctx.opts.entryPath ?? "index.html";
+  const html = textOf(entryPath, fileMap.get(entryPath));
+  if (!html || !/\.gif\b/i.test(html)) return;
+  const sourceAssets = entryGifSources(ctx, entryPath, html);
+  if (!sourceAssets) return;
+  const prep = ctx.opts.gifPrep ?? (await import("./src-NPR2JZOJ.js")).prepareAnimatedGifInputs;
+  const outputDir = mkdtempSync(join(tmpdir(), "hf-offload-gif-"));
+  ctx.tempFiles.push(outputDir);
+  const result = await prep(html, {
+    projectDir: ctx.absDir,
+    downloadDir: outputDir,
+    outputDir,
+    outputSrcPrefix: posix.relative(posix.dirname(entryPath), GIF_PREFIX),
+    cacheDir: join(homedir(), ".cache", "hyperframes", "animated-gif"),
+    sourceAssets
+  });
+  if (result.preparedGifs.length === 0) return;
+  fileMap.set(entryPath, Buffer.from(result.html, "utf-8"));
+  for (const gif of result.preparedGifs) {
+    fileMap.set(`${GIF_PREFIX}/${basename2(gif.outputPath)}`, readFileSync2(gif.outputPath));
+    const source = htmlSrcKey(ctx.absDir, entryPath, gif.sourceSrc.trim(), fileMap);
+    if (source) ctx.preparedGifSources.push(source);
+  }
+}
+function entryGifSources(ctx, entryPath, html) {
+  const sourceAssets = /* @__PURE__ */ new Map();
+  let heavy = false;
+  for (const img of parseHTML(html).document.querySelectorAll("img[src]")) {
+    const src = img.getAttribute("src").trim();
+    const key = htmlSrcKey(ctx.absDir, entryPath, src, ctx.fileMap);
+    if (!key?.toLowerCase().endsWith(".gif")) continue;
+    const file = ctx.fileMap.get(key);
+    sourceAssets.set(src, stagedCopy(key, file, ctx.tempFiles));
+    heavy ||= stagedSize(file) >= OFFLOAD_MIN_BYTES;
+  }
+  return heavy ? sourceAssets : null;
+}
+async function offloadHeavyMedia(projectDir, fileMap, opts) {
+  const cachePath = opts.cachePath ?? defaultOffloadCachePath();
+  const ctx = {
+    absDir: resolve(projectDir),
+    opts,
+    cachePath,
+    cache: readCache(cachePath),
+    fetchImpl: opts.fetchImpl ?? fetch,
+    reencoder: opts.reencoder ?? ffmpegReencoder,
+    tempFiles: [],
+    preparedGifSources: [],
+    fileMap
+  };
+  const urls = /* @__PURE__ */ new Map();
+  const report = [];
+  try {
+    await prepareEntryGifs(ctx, fileMap);
+    const referenced = referencedFiles(ctx.absDir, fileMap);
+    for (const [path, file] of [...fileMap].sort(([a], [b]) => a.localeCompare(b))) {
+      if (!referenced.has(path)) continue;
+      const item = await offloadFile(ctx, path, file);
+      if (!item) continue;
+      urls.set(path, item.url ?? `https://assets.invalid/${report.length}`);
+      report.push(item);
+      opts.onFile?.(item);
+    }
+  } finally {
+    for (const dir of ctx.tempFiles) rmSync(dir, { recursive: true, force: true });
+  }
+  if (urls.size > 0) rewriteReferences(ctx.absDir, fileMap, (key) => urls.get(key) ?? null);
+  dropReplacedFiles(fileMap, report, ctx.preparedGifSources, [...urls.values()]);
+  return report;
+}
+function dropReplacedFiles(fileMap, report, preparedGifSources, assetUrls) {
+  const withoutUrls = (text) => assetUrls.reduce((acc, url) => acc.replaceAll(url, ""), text);
+  const code = withoutUrls(scriptCode(fileMap));
+  for (const item of report) {
+    if (isStillMentioned(fileMap, item.path, code, withoutUrls)) item.kept_in_archive = true;
+    else fileMap.delete(item.path);
+  }
+  for (const gif of preparedGifSources) {
+    if (!isStillMentioned(fileMap, gif, code, withoutUrls)) fileMap.delete(gif);
+  }
+}
+function isStillMentioned(fileMap, path, code, withoutUrls) {
+  const ext = extname(path);
+  if (code.includes(basename2(path, ext)) && code.includes(ext.slice(1))) return true;
+  const name = basename2(path);
+  for (const [entryPath, content] of fileMap) {
+    const contentText = textOf(entryPath, content);
+    if (entryPath === path || !contentText?.includes(name)) continue;
+    if (withoutUrls(contentText).includes(name)) return true;
+  }
+  return false;
+}
+function htmlSrcKey(absDir, entryPath, raw, fileMap) {
+  const clean = cleanAssetUrl(raw);
+  if (!clean || isRemoteOrInlineUrl(clean)) return null;
+  const rootRelative = clean.startsWith("/") ? clean : rewriteAssetPath(entryPath, clean, (p) => fileMap.has(p));
+  for (const candidate of resolveLocalAssetCandidates(absDir, rootRelative)) {
+    const key = relative(absDir, candidate).replaceAll("\\", "/");
+    if (fileMap.has(key)) return key;
+  }
+  return null;
+}
+function referencedFiles(absDir, fileMap) {
+  const keys = /* @__PURE__ */ new Set();
+  rewriteReferences(absDir, fileMap, (key) => {
+    if (fileMap.has(key)) keys.add(key);
+    return null;
+  });
+  return keys;
+}
+function rewriteReferences(absDir, fileMap, urlForKey) {
+  const urlFor = (rootRelative) => {
+    for (const candidate of resolveLocalAssetCandidates(absDir, rootRelative)) {
+      const url = urlForKey(relative(absDir, candidate).replaceAll("\\", "/"));
+      if (url) return url;
+    }
+    return null;
+  };
+  for (const [entryPath, content] of [...fileMap]) {
+    const rewrite = rewriterFor(absDir, entryPath, urlFor, fileMap);
+    const text = rewrite ? textOf(entryPath, content) : void 0;
+    const next = rewrite && text !== void 0 ? rewrite(text) : null;
+    if (next !== null) fileMap.set(entryPath, Buffer.from(next, "utf-8"));
+  }
+}
+function rewriterFor(absDir, entryPath, urlFor, fileMap) {
+  if (/\.html?$/i.test(entryPath)) {
+    return (text) => rewriteHtmlEntry(absDir, entryPath, text, urlFor, fileMap);
+  }
+  if (/\.css$/i.test(entryPath)) return (text) => rewriteCssEntry(absDir, entryPath, text, urlFor);
+  if (/\.(m?js|cjs|json)$/i.test(entryPath)) return (text) => rewriteStringLiterals(text, urlFor);
+  return null;
+}
+function localTarget(raw, toRootRelative, urlFor) {
+  const clean = cleanAssetUrl(raw);
+  if (!clean || isRemoteOrInlineUrl(clean)) return null;
+  const url = urlFor(clean.startsWith("/") ? clean : toRootRelative(clean));
+  return url && url + raw.trim().slice(clean.length);
+}
+function rewriteCssEntry(absDir, entryPath, css, urlFor) {
+  const result = rewriteCssUrls(
+    css,
+    resolve(absDir, dirname(entryPath)),
+    entryPath,
+    (raw) => localTarget(raw, (clean) => posix.join(posix.dirname(entryPath), clean), urlFor)
+  );
+  return result.modified ? result.css : null;
+}
+function rewriteHtmlEntry(absDir, entryPath, html, urlFor, fileMap) {
+  const referrerAbsDir = resolve(absDir, dirname(entryPath));
+  const resolveTarget = (raw) => localTarget(raw, (clean) => rewriteAssetPath(entryPath, clean, (p) => fileMap.has(p)), urlFor);
+  const { document } = parseHTML(html);
+  const attrs = rewriteHtmlAttributes(document, referrerAbsDir, entryPath, resolveTarget, {
+    attrs: ["src", "poster", "href"]
+  });
+  const srcsets = rewriteSrcsets(document, resolveTarget);
+  const styles = rewriteStyleBlocks(document, referrerAbsDir, entryPath, resolveTarget);
+  let scripts = false;
+  for (const script of document.querySelectorAll("script")) {
+    if (script.hasAttribute("src")) continue;
+    const next = rewriteStringLiterals(script.textContent ?? "", urlFor);
+    if (next === null) continue;
+    script.textContent = next;
+    scripts = true;
+  }
+  return attrs || srcsets || styles || scripts ? document.toString() : null;
+}
+var STRING_LITERAL_RE = /(["'`])([^"'`\\\n$]+)\1/g;
+function rewriteStringLiterals(code, urlFor) {
+  let modified = false;
+  const next = code.replace(STRING_LITERAL_RE, (full, quote, value) => {
+    const url = localTarget(value, (clean) => clean, urlFor);
+    if (!url) return full;
+    modified = true;
+    return `${quote}${url}${quote}`;
+  });
+  return modified ? next : null;
+}
+function rewriteSrcsets(document, resolveTarget) {
+  let modified = false;
+  for (const el of document.querySelectorAll("[srcset]")) {
+    const srcset = el.getAttribute("srcset") ?? "";
+    if (srcset.includes("data:")) continue;
+    let changed = false;
+    const next = srcset.split(",").map((part) => {
+      const [url, ...descriptors] = part.trim().split(/\s+/);
+      const target = url ? resolveTarget(url, "") : null;
+      if (!target) return part.trim();
+      changed = true;
+      return [target, ...descriptors].join(" ");
+    }).join(", ");
+    if (changed) {
+      el.setAttribute("srcset", next);
+      modified = true;
+    }
+  }
+  return modified;
+}
+
+// src/commands/cloud/render.ts
+import { isAbsolute, relative as relative2, resolve as resolvePath } from "path";
+import { existsSync } from "fs";
+var VALID_QUALITY = ["draft", "standard", "high"];
+var VALID_FORMAT = ["mp4", "webm", "mov"];
+var VALID_RESOLUTION = ["1080p", "4k"];
+var VALID_ASPECT_RATIO = ["16:9", "9:16", "1:1"];
+var DIRECT_UPLOAD_LIMIT_BYTES = 200 * 1024 * 1024;
+var ARCHIVE_DIAGNOSTIC_THRESHOLD_BYTES = 150 * 1024 * 1024;
+var LARGEST_FILE_COUNT = 10;
+var FORMAT_EXT = { mp4: ".mp4", webm: ".webm", mov: ".mov" };
+var examples = [
+  ["Render the current directory in the cloud", "hyperframes cloud render"],
+  ["Inspect archive size without uploading", "hyperframes cloud render --dry-run"],
+  [
+    "Pick a specific composition + output path",
+    "hyperframes cloud render . --composition compositions/intro.html -o ./renders/intro.mp4"
+  ],
+  ["Higher quality, 60fps", "hyperframes cloud render --quality high --fps 60"],
+  [
+    "Submit and exit; webhook fires when the render terminates",
+    "hyperframes cloud render --callback-url https://example.com/hook --no-wait"
+  ],
+  [
+    "Override variables (parametrized render)",
+    `hyperframes cloud render --variables '{"title":"Q4 Recap","theme":"dark"}'`
+  ],
+  ["Re-render an already-uploaded zip", "hyperframes cloud render --asset-id asst_abc123"]
+];
+var render_default = defineCommand({
+  meta: { name: "render", description: "Render a HyperFrames composition in the cloud" },
+  args: {
+    dir: { type: "positional", required: false, description: "Project directory (default: .)" },
+    fps: { type: "string", description: "Frames per second (1-240). Default: 30." },
+    quality: { type: "string", description: "draft | standard | high (default: standard)" },
+    format: { type: "string", description: "mp4 | webm | mov (default: mp4)" },
+    resolution: {
+      type: "string",
+      description: "Resolution tier: 1080p | 4k (default: 1080p; 4k is billed at 1.5x)"
+    },
+    "aspect-ratio": {
+      type: "string",
+      description: "Aspect ratio: 16:9 | 9:16 | 1:1 (default: 16:9)"
+    },
+    composition: {
+      type: "string",
+      alias: "c",
+      description: "Entry HTML file inside the zip (default: index.html)"
+    },
+    variables: {
+      type: "string",
+      description: `Inline JSON object overriding data-composition-variables. Example: --variables '{"title":"X"}'`
+    },
+    "variables-file": {
+      type: "string",
+      description: "Path to a JSON file with variable values (alternative to --variables)"
+    },
+    "strict-variables": {
+      type: "boolean",
+      description: "Fail when --variables keys are undeclared or have the wrong type",
+      default: false
+    },
+    title: {
+      type: "string",
+      description: "Free-text label echoed back in detail responses"
+    },
+    "callback-url": {
+      type: "string",
+      description: "HTTPS webhook fired when the render terminates. Fires regardless of whether the CLI is still polling \u2014 combine with --no-wait for true fire-and-forget."
+    },
+    "callback-id": {
+      type: "string",
+      description: "Opaque tracking ID echoed in webhook payloads"
+    },
+    "asset-id": {
+      type: "string",
+      description: "Skip zip+upload and submit an already-uploaded composition. Mutually exclusive with --url and the project dir."
+    },
+    url: {
+      type: "string",
+      description: "Public HTTPS URL of a composition zip. Mutually exclusive with --asset-id and the project dir."
+    },
+    // Citty parses `--no-FOO` as `--FOO=false`. A flag literally named
+    // "no-wait" gets routed as `args.wait=false`, leaving
+    // `args["no-wait"]` undefined and the early-return for
+    // fire-and-forget mode unreachable. Named the arg `wait` so the
+    // user-facing `--no-wait` flag works via citty's negation; the
+    // run() body checks `if (!args.wait)`.
+    wait: {
+      type: "boolean",
+      description: "Poll until completion and download the video (default: true). Pass `--no-wait` for fire-and-forget \u2014 submits and exits with the render_id.",
+      default: true
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Destination path for the downloaded video (default: renders/<render_id>.<ext>)"
+    },
+    "poll-interval": {
+      type: "string",
+      description: `Poll cadence in seconds (default: ${DEFAULT_POLL_INTERVAL_MS / 1e3})`
+    },
+    "max-wait": {
+      type: "string",
+      description: `Max poll duration in minutes (default: ${DEFAULT_MAX_WAIT_MS / 6e4})`
+    },
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON instead of human-friendly progress",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Build and inspect the project zip without authenticating or uploading",
+      default: false
+    },
+    "idempotency-key": {
+      type: "string",
+      description: "Optional Idempotency-Key for safe retries (1-255 chars from [A-Za-z0-9_:.-])"
+    }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    const asJson = Boolean(args.json);
+    const fps = parseIntFlag(args.fps, { flag: "--fps", min: 1, max: 240 });
+    const quality = parseEnumFlag(args.quality, VALID_QUALITY, { flag: "--quality" });
+    const format = parseEnumFlag(args.format, VALID_FORMAT, { flag: "--format" });
+    const resolution = parseEnumFlag(args.resolution, VALID_RESOLUTION, {
+      flag: "--resolution"
+    });
+    const explicitAspectRatio = parseEnumFlag(args["aspect-ratio"], VALID_ASPECT_RATIO, {
+      flag: "--aspect-ratio"
+    });
+    const pollIntervalMs = parsePollIntervalMs(args["poll-interval"]);
+    const maxWaitMs = parseMaxWaitMs(args["max-wait"]);
+    validateIdempotencyKey(args["idempotency-key"]);
+    const project = resolveProjectInput({
+      dir: args.dir,
+      assetId: args["asset-id"],
+      url: args.url
+    });
+    validateDryRunSource(project, args["dry-run"] ?? false);
+    const aspectRatio = resolveAspectRatioForSubmit(
+      project,
+      args.composition,
+      explicitAspectRatio,
+      asJson
+    );
+    if (args["dry-run"]) {
+      if (project.kind !== "dir") throw new Error("Dry-run project must be a local directory");
+      reportDryRun(await prepareLocalArchive(project, args.composition, asJson), asJson);
+      return;
+    }
+    const variables = resolveVariablesAndValidateIfLocal(
+      args.variables,
+      args["variables-file"],
+      args["strict-variables"] ?? false,
+      project
+    );
+    const client = await createCloudClient();
+    const preparedArchive = project.kind === "dir" ? await prepareLocalArchive(
+      project,
+      args.composition,
+      asJson,
+      (file) => uploadAssetViaDirectUpload({ client, ...file })
+    ) : void 0;
+    const upload = await maybeUploadProject(
+      client,
+      project,
+      preparedArchive,
+      asJson,
+      args["idempotency-key"]
+    );
+    const submitted = await submitRender(client, {
+      projectInput: upload.projectInput,
+      fps,
+      quality,
+      format,
+      resolution,
+      aspectRatio,
+      composition: args.composition,
+      variables,
+      title: args.title,
+      callbackUrl: args["callback-url"],
+      callbackId: args["callback-id"],
+      idempotencyKey: args["idempotency-key"]
+    });
+    const renderId = submitted.render_id;
+    if (!args.wait) {
+      if (asJson) {
+        console.log(
+          JSON.stringify(
+            withMeta({ render: { render_id: renderId, status: "queued" } }),
+            null,
+            2
+          )
+        );
+      } else {
+        console.log("");
+        console.log(`${c.success("\u2713")}  Submitted ${c.accent(renderId)}`);
+        console.log(c.dim(`   Poll with: hyperframes cloud get ${renderId}`));
+      }
+      return;
+    }
+    if (!asJson) {
+      console.log("");
+      console.log(c.dim(`  Polling ${renderId} every ${pollIntervalMs / 1e3}s \u2026`));
+    }
+    const detail = await pollWithProgress(client, renderId, asJson, {
+      intervalMs: pollIntervalMs,
+      maxWaitMs
+    });
+    if (detail.status === "failed") {
+      handleFailedRender(detail, asJson);
+    }
+    if (!detail.video_url) {
+      errorBox(
+        "Render completed but returned no video_url",
+        `render_id: ${renderId}. Try \`hyperframes cloud get ${renderId}\` to inspect raw fields.`
+      );
+      failCommand();
+    }
+    const outputPath = resolveOutputPath(args.output, renderId, detail.format);
+    const downloadResult = await streamVideo(detail.video_url, outputPath, asJson);
+    if (asJson) {
+      console.log(
+        JSON.stringify(
+          withMeta({
+            render: detail,
+            output_path: outputPath,
+            bytes_written: downloadResult.bytes
+          }),
+          null,
+          2
+        )
+      );
+    }
+  }
+});
+function parsePollIntervalMs(raw) {
+  const n = parseNumericFlag(raw, { flag: "--poll-interval", min: 1 });
+  return n === void 0 ? DEFAULT_POLL_INTERVAL_MS : Math.round(n * 1e3);
+}
+function parseMaxWaitMs(raw) {
+  const n = parseNumericFlag(raw, { flag: "--max-wait", min: 1e-4 });
+  return n === void 0 ? DEFAULT_MAX_WAIT_MS : Math.round(n * 6e4);
+}
+var IDEMPOTENCY_KEY_RE = /^[A-Za-z0-9_:.-]{1,255}$/;
+function validateIdempotencyKey(key) {
+  if (key === void 0) return;
+  if (!IDEMPOTENCY_KEY_RE.test(key)) {
+    errorBox("Invalid --idempotency-key", `Got "${key}". Must be 1-255 chars from [A-Za-z0-9_:.-]`);
+    failCommand();
+  }
+}
+function validateDryRunSource(source, dryRun) {
+  if (!dryRun || source.kind === "dir") return;
+  errorBox(
+    "Invalid --dry-run input",
+    "--dry-run inspects a local project directory and cannot be combined with --asset-id or --url."
+  );
+  failCommand();
+}
+function resolveProjectInput(opts) {
+  const explicit = {
+    dir: opts.dir !== void 0 && opts.dir !== "",
+    assetId: opts.assetId !== void 0 && opts.assetId !== "",
+    url: opts.url !== void 0 && opts.url !== ""
+  };
+  const count = Number(explicit.dir) + Number(explicit.assetId) + Number(explicit.url);
+  if (count > 1) {
+    errorBox("Conflicting inputs", "Pass only one of: project dir, --asset-id, --url.");
+    failCommand();
+  }
+  if (explicit.assetId) return { kind: "asset_id", assetId: opts.assetId };
+  if (explicit.url) return { kind: "url", url: opts.url };
+  return { kind: "dir", dir: opts.dir ?? "." };
+}
+function resolveAspectRatioForSubmit(project, compositionArg, explicit, asJson) {
+  if (project.kind !== "dir") {
+    if (!explicit) {
+      const reason = project.kind === "asset_id" ? "--asset-id" : "--url";
+      logDetection(asJson, `Auto-detect skipped (project is ${reason})`);
+    }
+    return explicit;
+  }
+  const dir = project.dir ?? ".";
+  const entryRelative = compositionArg ?? "index.html";
+  const entryPath = resolvePath(dir, entryRelative);
+  if (!existsSync(entryPath)) {
+    errorBox(
+      "Composition not found",
+      `Entry file "${entryRelative}" does not exist in ${dir}.`,
+      "Pass --composition with a path that exists inside the project, or omit it to use index.html."
+    );
+    failCommand();
+  }
+  const detection = detectAspectRatioFromHtml(entryPath);
+  if (explicit) {
+    const conflictDetail = detection.kind === "matched" && detection.aspectRatio !== explicit ? `${detection.width}\xD7${detection.height} \u2192 ${detection.aspectRatio}` : detection.kind === "no-match" ? `${detection.width}\xD7${detection.height}, ratio ${detection.ratio.toFixed(2)} \u2014 not a supported ratio` : void 0;
+    if (conflictDetail) {
+      errorBox(
+        "Aspect ratio mismatch",
+        `--aspect-ratio ${explicit} doesn't match the composition (${conflictDetail}).`,
+        "The renderer matches the composition's authored aspect ratio \u2014 it can't reshape it. Drop --aspect-ratio (it's auto-detected) or re-author the composition at the target ratio."
+      );
+      failCommand();
+    }
+    return explicit;
+  }
+  logDetection(asJson, summarizeDetection(detection, entryRelative));
+  return detection.kind === "matched" ? detection.aspectRatio : void 0;
+}
+var ASPECT_FALLBACK_HINT = "server will default aspect_ratio to 16:9. Pass --aspect-ratio to override.";
+function logDetection(asJson, message) {
+  if (asJson) return;
+  const suffix = message.startsWith("Detected aspect ratio") ? "" : `; ${ASPECT_FALLBACK_HINT}`;
+  console.log(c.dim(`   ${message}${suffix}`));
+}
+function summarizeDetection(detection, entryRelative) {
+  switch (detection.kind) {
+    case "matched":
+      return `Detected aspect ratio: ${detection.aspectRatio} (from ${entryRelative} dims ${detection.width}\xD7${detection.height})`;
+    case "no-root-div":
+      return `No <div data-composition-id> found in ${entryRelative}`;
+    case "no-dims":
+      return `${entryRelative} root composition has no data-width / data-height`;
+    case "invalid-dims":
+      return `${entryRelative} root has invalid dims (${detection.width}\xD7${detection.height})`;
+    case "no-match":
+      return `${entryRelative} dims ${detection.width}\xD7${detection.height} (ratio ${detection.ratio.toFixed(2)}) don't match 16:9, 9:16, or 1:1`;
+    case "read-error":
+      return `Couldn't read ${entryRelative} for aspect-ratio detection (${detection.error})`;
+  }
+}
+function resolveVariablesAndValidateIfLocal(inline, filePath, strict, source) {
+  const variables = resolveVariablesArg(inline, filePath);
+  if (!variables || Object.keys(variables).length === 0) return variables;
+  if (source.kind !== "dir") return variables;
+  const { indexPath } = resolveProject(source.dir);
+  const issues = validateVariablesAgainstProject(indexPath, variables);
+  reportVariableIssues(issues, { strict, quiet: false });
+  return variables;
+}
+function summarizeLargestFiles(fileMap) {
+  return [...fileMap.entries()].map(([path, content]) => ({ path, size_bytes: stagedSize(content) })).sort((a, b) => b.size_bytes - a.size_bytes || a.path.localeCompare(b.path)).slice(0, LARGEST_FILE_COUNT);
+}
+async function prepareLocalArchive(source, composition, asJson, upload) {
+  const project = resolveProject(source.dir);
+  if (!asJson) {
+    console.log("");
+    console.log(`${c.accent("\u25C6")}  Zipping ${c.accent(project.name)}`);
+  }
+  const { fileMap, entryPath } = stageProjectFiles(project, composition);
+  const offloaded = await offloadMedia(project, fileMap, entryPath, asJson, upload);
+  const onDiskBytes = [...fileMap.values()].filter((file) => !Buffer.isBuffer(file)).reduce((sum, file) => sum + stagedSize(file), 0);
+  const archive = onDiskBytes > DIRECT_UPLOAD_LIMIT_BYTES ? void 0 : zipPublishFileMap(new Map([...fileMap].map(([path, file]) => [path, readStaged(file)])));
+  const sizeBytes = archive?.buffer.byteLength ?? onDiskBytes;
+  if (!asJson) {
+    console.log(c.dim(`   ${fileMap.size} files \xB7 ${formatBytes(sizeBytes)}`));
+  }
+  const largestFiles = summarizeLargestFiles(fileMap);
+  const prepared = {
+    project,
+    archive,
+    sizeBytes,
+    fileCount: fileMap.size,
+    largestFiles,
+    offloaded
+  };
+  if (upload) assertArchiveFits(sizeBytes, largestFiles);
+  if (!asJson && sizeBytes >= ARCHIVE_DIAGNOSTIC_THRESHOLD_BYTES) {
+    reportLargestFiles(prepared);
+  }
+  return prepared;
+}
+function stageProjectFiles(project, composition) {
+  try {
+    const fileMap = stagePublishFiles(project.dir, OFFLOAD_MIN_BYTES);
+    const entryPath = relative2(
+      project.dir,
+      resolvePath(project.dir, composition ?? "index.html")
+    ).replaceAll("\\", "/");
+    if (!fileMap.has(entryPath)) {
+      throw new Error(
+        `Composition "${composition ?? "index.html"}" is excluded from the archive. Check .hyperframesignore.`
+      );
+    }
+    return { fileMap, entryPath };
+  } catch (err) {
+    const msg = normalizeErrorMessage(err);
+    errorBox("Zip failed", msg, "Check the project and .hyperframesignore for missing files.");
+    failCommand();
+  }
+}
+async function offloadMedia(project, fileMap, entryPath, asJson, upload) {
+  let offloaded;
+  try {
+    offloaded = await offloadHeavyMedia(project.dir, fileMap, {
+      apiBaseUrl: resolveCloudBaseUrl(),
+      upload,
+      entryPath,
+      onFile: asJson ? void 0 : (item) => console.log(c.dim(`   ${describeOffload(item, !upload)}`))
+    });
+  } catch (err) {
+    reportApiError("Media upload failed", err);
+  }
+  if (!asJson) {
+    for (const item of offloaded.filter((entry) => entry.kept_in_archive)) {
+      console.log(
+        c.dim(
+          `   ${item.path} also stays in the zip: a script builds its path in a way that cannot be rewritten`
+        )
+      );
+    }
+  }
+  return offloaded;
+}
+function assertArchiveFits(sizeBytes, largestFiles) {
+  if (sizeBytes <= DIRECT_UPLOAD_LIMIT_BYTES) return;
+  errorBox(
+    "Project too large for cloud render",
+    `The zip is ${formatBytes(sizeBytes)} after moving media to HeyGen assets, over the ${formatBytes(DIRECT_UPLOAD_LIMIT_BYTES)} upload limit. Largest files left in it:
+${largestFiles.map((file) => `  ${formatBytes(file.size_bytes).padStart(9)}  ${file.path}`).join("\n")}`,
+    "Exclude files the render does not need with .hyperframesignore."
+  );
+  failCommand();
+}
+function describeOffload(item, dryRun) {
+  const verb = item.action === "cached" ? "already uploaded" : item.action === "reencode" ? dryRun ? "would re-encode and upload" : "re-encoded and uploaded" : dryRun ? "would upload" : "uploaded";
+  return `${formatBytes(item.size_bytes).padStart(9)}  ${item.path} \xB7 ${verb}`;
+}
+function reportLargestFiles(prepared) {
+  console.log(c.dim("   Largest included files:"));
+  for (const file of prepared.largestFiles) {
+    console.log(c.dim(`   ${formatBytes(file.size_bytes).padStart(9)}  ${file.path}`));
+  }
+  console.log(c.dim("   Exclude verified-unneeded files with .hyperframesignore."));
+}
+function reportDryRun(prepared, asJson) {
+  const { sizeBytes } = prepared;
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        withMeta({
+          archive: {
+            project: prepared.project.name,
+            file_count: prepared.fileCount,
+            size_bytes: sizeBytes,
+            upload_limit_bytes: DIRECT_UPLOAD_LIMIT_BYTES,
+            exceeds_upload_limit: sizeBytes > DIRECT_UPLOAD_LIMIT_BYTES,
+            largest_files: prepared.largestFiles,
+            offloaded_media: prepared.offloaded
+          }
+        }),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (sizeBytes < ARCHIVE_DIAGNOSTIC_THRESHOLD_BYTES) reportLargestFiles(prepared);
+  console.log("");
+  console.log(`${c.success("\u2713")}  Dry run complete \u2014 nothing uploaded`);
+  if (sizeBytes > DIRECT_UPLOAD_LIMIT_BYTES) {
+    console.log(c.warn(`   Archive exceeds the 200 MB direct-upload limit.`));
+  }
+}
+async function maybeUploadProject(client, source, preparedArchive, asJson, idempotencyKey) {
+  if (source.kind === "asset_id") {
+    return { projectInput: { type: "asset_id", asset_id: source.assetId } };
+  }
+  if (source.kind === "url") {
+    return { projectInput: { type: "url", url: source.url } };
+  }
+  if (!preparedArchive) throw new Error("Local project archive was not prepared");
+  const { project, archive } = preparedArchive;
+  if (!archive) throw new Error("Local project archive is over the upload limit");
+  if (!asJson) {
+    console.log("");
+    console.log(`${c.accent("\u25C6")}  Uploading (direct-to-S3)`);
+  }
+  const uploadStart = Date.now();
+  let uploaded;
+  try {
+    uploaded = await uploadZipViaDirectUpload({
+      client,
+      bytes: archive.buffer,
+      filename: `${project.name}.zip`,
+      idempotencyKey,
+      onProgress: !asJson ? (ev) => {
+        if (ev.phase === "initialize") {
+          console.log(c.dim(`   initializing\u2026`));
+        } else if (ev.phase === "upload" && ev.percent === 0) {
+          console.log(c.dim(`   uploading to S3\u2026`));
+        } else if (ev.phase === "complete") {
+          console.log(c.dim(`   finalizing\u2026`));
+        }
+      } : void 0
+    });
+  } catch (err) {
+    reportApiError("Upload failed", err);
+  }
+  if (!asJson) {
+    console.log(
+      c.dim(
+        `   asset_id: ${c.accent(uploaded.asset_id)} \xB7 ${formatDuration(Date.now() - uploadStart)}`
+      )
+    );
+  }
+  return { projectInput: { type: "asset_id", asset_id: uploaded.asset_id } };
+}
+async function submitRender(client, opts) {
+  const body = buildRenderBody(opts);
+  try {
+    return await client.createRender({ body, idempotencyKey: opts.idempotencyKey });
+  } catch (err) {
+    reportApiError("Submit failed", err);
+  }
+}
+function buildRenderBody(opts) {
+  const body = { project: opts.projectInput };
+  if (opts.fps !== void 0) body.fps = opts.fps;
+  if (opts.quality !== void 0) body.quality = opts.quality;
+  if (opts.format !== void 0) body.format = opts.format;
+  if (opts.resolution !== void 0) body.resolution = opts.resolution;
+  if (opts.aspectRatio !== void 0) body.aspect_ratio = opts.aspectRatio;
+  if (opts.composition !== void 0) body.composition = opts.composition;
+  if (opts.variables !== void 0) body.variables = opts.variables;
+  if (opts.title !== void 0) body.title = opts.title;
+  if (opts.callbackUrl !== void 0) body.callback_url = opts.callbackUrl;
+  if (opts.callbackId !== void 0) body.callback_id = opts.callbackId;
+  return body;
+}
+async function pollWithProgress(client, renderId, asJson, poll) {
+  const interactive = !asJson && process.stdout.isTTY === true;
+  let lastStatus = "";
+  try {
+    return await pollUntilTerminal(client, renderId, {
+      intervalMs: poll.intervalMs,
+      maxWaitMs: poll.maxWaitMs,
+      // fallow-ignore-next-line complexity
+      onTick: (detail, elapsedMs) => {
+        if (asJson) return;
+        if (interactive) {
+          if (detail.status === lastStatus) {
+            process.stdout.write(`\r\x1B[2K  ${formatTickLine(detail, elapsedMs)}`);
+          } else {
+            if (lastStatus) process.stdout.write("\n");
+            process.stdout.write(`  ${formatTickLine(detail, elapsedMs)}`);
+            lastStatus = detail.status;
+          }
+        } else if (detail.status !== lastStatus) {
+          console.log(`  ${formatTickLine(detail, elapsedMs)}`);
+          lastStatus = detail.status;
+        }
+      }
+    });
+  } catch (err) {
+    if (!asJson && lastStatus && interactive) process.stdout.write("\n");
+    if (err instanceof PollTimeoutError) {
+      errorBox(
+        "Poll timed out",
+        err.message,
+        `The render may still complete. Resume with: hyperframes cloud get ${renderId}`
+      );
+      failCommand();
+    }
+    return reportApiError("API error during poll", err, {
+      suggestion: `The render may still be running. Resume with: hyperframes cloud get ${renderId}`
+    });
+  } finally {
+    if (!asJson && lastStatus && interactive) process.stdout.write("\n");
+  }
+}
+function formatTickLine(detail, elapsedMs) {
+  const status = colorStatus(detail.status);
+  return `${status}  ${c.dim(formatDuration(elapsedMs))}`;
+}
+function handleFailedRender(detail, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify(withMeta({ render: detail }), null, 2));
+    failCommand();
+  }
+  errorBox(
+    "Render failed",
+    detail.failure_message ?? "(no failure_message returned)",
+    `Inspect: hyperframes cloud get ${detail.render_id}`
+  );
+  failCommand();
+}
+function resolveOutputPath(output, renderId, format) {
+  if (output) {
+    return isAbsolute(output) ? output : resolvePath(process.cwd(), output);
+  }
+  const ext = FORMAT_EXT[format] ?? `.${format}`;
+  return resolvePath(process.cwd(), "renders", `${renderId}${ext}`);
+}
+async function streamVideo(url, destPath, asJson) {
+  if (!asJson) {
+    console.log("");
+    console.log(`${c.accent("\u25C6")}  Downloading to ${c.accent(destPath)}`);
+  }
+  try {
+    const result = await downloadToFile(url, destPath);
+    if (!asJson) {
+      console.log(c.dim(`   ${formatBytes(result.bytes)} written`));
+    }
+    return { bytes: result.bytes };
+  } catch (err) {
+    const message = normalizeErrorMessage(err);
+    errorBox(
+      "Download failed",
+      message,
+      "The presigned URL is short-lived; re-fetch with `hyperframes cloud get`."
+    );
+    failCommand();
+  }
+}
+export {
+  assertArchiveFits,
+  render_default as default,
+  examples,
+  resolveAspectRatioForSubmit,
+  validateDryRunSource
+};