@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/render-TTQI7TGN.js

@@ -0,0 +1,796 @@
+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-RVCWIIZ7.js";
+import {
+  colorStatus
+} from "./chunk-U7CZBDMV.js";
+import {
+  DEFAULT_MAX_WAIT_MS,
+  DEFAULT_POLL_INTERVAL_MS,
+  HyperframesApiError,
+  PollTimeoutError,
+  createCloudClient,
+  pollUntilTerminal,
+  reportApiError
+} from "./chunk-Y6W4DVPS.js";
+import {
+  downloadToFile
+} from "./chunk-BXCMXMJQ.js";
+import {
+  reportVariableIssues,
+  resolveVariablesArg,
+  validateVariablesAgainstProject
+} from "./chunk-6CTIGJY7.js";
+import {
+  buildPublishFileMap,
+  zipPublishFileMap
+} from "./chunk-JH556Q42.js";
+import "./chunk-ZTZ7NCJT.js";
+import "./chunk-SHB5VDMH.js";
+import "./chunk-I465DBM6.js";
+import "./chunk-EOVYQ3IG.js";
+import {
+  resolveProject
+} from "./chunk-S3D6GE5W.js";
+import {
+  errorBox,
+  formatBytes,
+  formatDuration
+} from "./chunk-IHFUKJOR.js";
+import "./chunk-PFCFR3KZ.js";
+import "./chunk-JTHMTOMQ.js";
+import "./chunk-EISRN4E6.js";
+import "./chunk-VWG7OQKU.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-IUZFXWSV.js";
+import "./chunk-AMKC3AXA.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import {
+  failCommand
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-TWWSYAKJ.js";
+import "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import {
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-FLWXXDNS.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.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/upload.ts
+import { createHash } from "crypto";
+var COMPLETE_MAX_RETRIES = 5;
+var COMPLETE_RETRY_BASE_MS = 500;
+var CONTENT_TYPE_ZIP = "application/zip";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function normalizeUploadHeaders(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw ?? {})) {
+    if (typeof v === "string") out[k] = v;
+    else if (typeof v === "number" || typeof v === "boolean") out[k] = String(v);
+  }
+  return out;
+}
+async function putBytesToPresignedUrl(fetchImpl, uploadUrl, uploadHeaders, bytes) {
+  const headers = {
+    "content-type": CONTENT_TYPE_ZIP,
+    ...normalizeUploadHeaders(uploadHeaders)
+  };
+  const res = await fetchImpl(uploadUrl, {
+    method: "PUT",
+    headers,
+    body: bytes
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    throw new Error(
+      `Direct upload PUT failed: ${res.status} ${res.statusText}${detail ? ` \u2014 ${detail.slice(0, 300)}` : ""}`
+    );
+  }
+}
+async function completeWithRetry(client, asset_id, checksum_sha256) {
+  let lastErr;
+  for (let attempt = 0; attempt < COMPLETE_MAX_RETRIES; attempt++) {
+    try {
+      return await client.completeAssetUpload({
+        asset_id,
+        body: { checksum_sha256 }
+      });
+    } catch (err) {
+      const retryable = err instanceof HyperframesApiError && err.status === 409;
+      if (!retryable || attempt === COMPLETE_MAX_RETRIES - 1) {
+        throw err;
+      }
+      lastErr = err;
+      await sleep(COMPLETE_RETRY_BASE_MS * (attempt + 1));
+    }
+  }
+  throw lastErr ?? new Error("completeAssetUpload retries exhausted");
+}
+async function uploadZipViaDirectUpload(opts) {
+  const start = Date.now();
+  const { bytes, filename, idempotencyKey } = opts;
+  const size_bytes = bytes.byteLength;
+  const checksum_sha256 = sha256Hex(bytes);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  opts.onProgress?.({ phase: "initialize" });
+  const initialize = await opts.client.createAssetUpload({
+    body: { filename, content_type: CONTENT_TYPE_ZIP, size_bytes, checksum_sha256 },
+    idempotencyKey
+  });
+  opts.onProgress?.({ phase: "upload", percent: 0 });
+  await putBytesToPresignedUrl(fetchImpl, initialize.upload_url, initialize.upload_headers, bytes);
+  opts.onProgress?.({ phase: "upload", percent: 100 });
+  opts.onProgress?.({ phase: "complete" });
+  const completed = await completeWithRetry(opts.client, initialize.asset_id, checksum_sha256);
+  return {
+    asset_id: completed.asset_id,
+    size_bytes,
+    duration_ms: Date.now() - start
+  };
+}
+
+// src/commands/cloud/render.ts
+import { isAbsolute, relative, 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);
+    validateResolutionFormatCombo(resolution, format);
+    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(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" ? prepareLocalArchive(project, args.composition, asJson) : 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;
+}
+function validateResolutionFormatCombo(resolution, format) {
+  if (resolution === "4k" && (format === "webm" || format === "mov")) {
+    errorBox(
+      "Unsupported combination",
+      `--resolution 4k cannot be combined with --format ${format}.`,
+      "The alpha (webm/mov) capture path doesn't support 4k supersampling. Render 4k as mp4, or render alpha at composition resolution."
+    );
+    failCommand();
+  }
+}
+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: content.byteLength })).sort((a, b) => b.size_bytes - a.size_bytes || a.path.localeCompare(b.path)).slice(0, LARGEST_FILE_COUNT);
+}
+function prepareLocalArchive(source, composition, asJson) {
+  const project = resolveProject(source.dir);
+  if (!asJson) {
+    console.log("");
+    console.log(`${c.accent("\u25C6")}  Zipping ${c.accent(project.name)}`);
+  }
+  try {
+    const fileMap = buildPublishFileMap(project.dir);
+    const entryPath = relative(
+      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.`
+      );
+    }
+    const archive = zipPublishFileMap(fileMap);
+    if (!asJson) {
+      console.log(
+        c.dim(`   ${archive.fileCount} files \xB7 ${formatBytes(archive.buffer.byteLength)}`)
+      );
+    }
+    const prepared = { project, archive, largestFiles: summarizeLargestFiles(fileMap) };
+    if (!asJson && archive.buffer.byteLength >= ARCHIVE_DIAGNOSTIC_THRESHOLD_BYTES) {
+      reportLargestFiles(prepared);
+    }
+    return prepared;
+  } catch (err) {
+    const msg = normalizeErrorMessage(err);
+    errorBox("Zip failed", msg, "Check the project and .hyperframesignore for missing files.");
+    failCommand();
+  }
+}
+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.archive.buffer.byteLength;
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        withMeta({
+          archive: {
+            project: prepared.project.name,
+            file_count: prepared.archive.fileCount,
+            size_bytes: sizeBytes,
+            upload_limit_bytes: DIRECT_UPLOAD_LIMIT_BYTES,
+            exceeds_upload_limit: sizeBytes > DIRECT_UPLOAD_LIMIT_BYTES,
+            largest_files: prepared.largestFiles
+          }
+        }),
+        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 (!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 {
+  render_default as default,
+  examples,
+  resolveAspectRatioForSubmit,
+  validateDryRunSource,
+  validateResolutionFormatCombo
+};