@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/cloudrun-HGJ3B6ZV.js

@@ -0,0 +1,767 @@
+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 {
+  parseOutputResolutionFlag
+} from "./chunk-ST35C4K6.js";
+import {
+  isMissingPackageError,
+  missingPackageMessage
+} from "./chunk-RVZHGOGR.js";
+import {
+  reportVariableIssues,
+  resolveVariablesArg,
+  validateVariablesAgainstProject
+} from "./chunk-EAMLBAHA.js";
+import {
+  defaultCloudFps
+} from "./chunk-KXTKKBOC.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-442JNXRM.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import {
+  DISTRIBUTED_FPS,
+  isDistributedFps
+} from "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/cloudrun.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var examples = [
+  ["Deploy the Cloud Run render stack", "framey cloudrun deploy --project my-gcp-project"],
+  [
+    "Render a composition on the deployed stack",
+    "framey cloudrun render ./my-project --width 1920 --height 1080 --wait"
+  ],
+  [
+    "Render a personalised template with variables",
+    `framey cloudrun render ./my-template --width 1920 --height 1080 --variables '{"title":"Hello Alice"}'`
+  ],
+  [
+    "Supersample a 1080p composition to 4K",
+    "framey cloudrun render ./my-project --width 1920 --height 1080 --output-resolution 4k --wait"
+  ],
+  [
+    "Batch-render N personalised videos from a JSONL file",
+    "framey cloudrun render-batch ./my-template --batch ./users.jsonl --width 1920 --height 1080 --max-concurrent 10"
+  ],
+  ["Check progress for a started render", "framey cloudrun progress <executionName>"],
+  ["Pre-upload a project so renders share the upload", "framey cloudrun sites create ./my-project"],
+  ["Tear the stack down", "framey cloudrun destroy --project my-gcp-project"]
+];
+var HELP = `
+${c.bold("framey cloudrun")} ${c.dim("<subcommand> [args]")}
+
+Deploy + drive distributed video renders on Google Cloud Run + Workflows.
+
+${c.bold("SUBCOMMANDS:")}
+  ${c.accent("deploy")}        ${c.dim("Build the image + apply the Terraform module (Cloud Run + Workflows + GCS)")}
+  ${c.accent("sites create")}  ${c.dim("Tar + upload a project to GCS (reusable across renders)")}
+  ${c.accent("render")}        ${c.dim("Start a distributed render (returns an execution name)")}
+  ${c.accent("render-batch")}  ${c.dim("Fan out N personalised renders from a JSONL batch file")}
+  ${c.accent("progress")}      ${c.dim("Print progress + cost for an in-flight or finished render")}
+  ${c.accent("destroy")}       ${c.dim("Tear the stack down")}
+
+${c.bold("FIRST RUN:")}
+  ${c.accent("framey cloudrun deploy --project my-gcp-project")}
+  ${c.accent("framey cloudrun render ./my-project --width 1920 --height 1080 --wait")}
+
+${c.bold("REQUIREMENTS:")}
+  \u2022 gcloud authenticated; the target project must have billing enabled
+  \u2022 terraform (>= 1.5) and docker / Cloud Build access on PATH
+`;
+var cloudRunAdapterPromise;
+function loadCloudRunAdapter() {
+  cloudRunAdapterPromise ??= Promise.all([
+    import("@framey/gcp-cloud-run/sdk"),
+    import("@framey/gcp-cloud-run/terraform")
+  ]).then(([sdk, terraform]) => ({ ...sdk, ...terraform }));
+  return cloudRunAdapterPromise;
+}
+function isMissingCloudRunAdapterError(error) {
+  return isMissingPackageError(error, "@framey/gcp-cloud-run");
+}
+function missingCloudRunAdapterMessage(subcommand) {
+  return missingPackageMessage("@framey/gcp-cloud-run", `framey cloudrun ${subcommand}`);
+}
+var cloudrun_default = defineCommand({
+  meta: { name: "cloudrun", description: "Deploy and drive renders on Google Cloud Run" },
+  args: {
+    subcommand: {
+      type: "positional",
+      required: false,
+      description: "deploy | sites | render | render-batch | progress | destroy"
+    },
+    target: {
+      type: "positional",
+      required: false,
+      description: "Subcommand positional (project dir, execution name, sites verb)"
+    },
+    extra: {
+      type: "positional",
+      required: false,
+      description: "Extra positional (e.g. `sites create <projectDir>`)"
+    },
+    // Stack identity
+    project: {
+      type: "string",
+      description: "GCP project id (required for deploy/destroy; cached after deploy)"
+    },
+    region: { type: "string", description: "GCP region (default: us-central1)" },
+    image: {
+      type: "string",
+      description: "Container image for the render service (deploy). If unset, deploy builds it via Cloud Build."
+    },
+    repo: {
+      type: "string",
+      description: "Artifact Registry repo for the built image (default: hyperframes)"
+    },
+    // Machine sizing / scaling (deploy). Omitted flags keep the Terraform
+    // module defaults (4 vCPU / 16Gi / 100 instances / 3600s).
+    cpu: { type: "string", description: "vCPU per Cloud Run instance: 1 | 2 | 4 | 8 (deploy)" },
+    memory: { type: "string", description: "Memory per instance, e.g. 16Gi | 32Gi (deploy)" },
+    "max-instances": {
+      type: "string",
+      description: "Max Cloud Run instances = render fan-out ceiling (deploy)"
+    },
+    timeout: {
+      type: "string",
+      description: "Per-request timeout in seconds, max 3600 (deploy)"
+    },
+    // sites / render
+    "site-id": { type: "string", description: "Explicit site id (overrides content hash)" },
+    width: { type: "string", description: "Render width in pixels" },
+    height: { type: "string", description: "Render height in pixels" },
+    fps: { type: "string", description: `Render fps (${DISTRIBUTED_FPS.join(" | ")})` },
+    format: { type: "string", description: "mp4 | mov | png-sequence | webm (default: mp4)" },
+    codec: { type: "string", description: "h264 | h265 (mp4 only)" },
+    quality: { type: "string", description: "draft | standard | high" },
+    "chunk-size": { type: "string", description: "Frames per chunk" },
+    "max-parallel-chunks": { type: "string", description: "Max concurrent chunks" },
+    "target-chunk-frames": {
+      type: "string",
+      description: "Cap per-chunk frames; auto-adds chunks (up to --max-parallel-chunks) to keep each under this. Ignored if --chunk-size is set."
+    },
+    "output-resolution": {
+      type: "string",
+      description: "Output resolution preset that engages Chrome deviceScaleFactor supersampling (e.g. 4k, 1080p, landscape-4k). The composition's authored data-width/data-height is supersampled to the target without changing layout."
+    },
+    variables: {
+      type: "string",
+      description: `JSON object of composition variable values, e.g. --variables '{"title":"Hi"}'`
+    },
+    "variables-file": { type: "string", description: "Path to a JSON file of variable values" },
+    "strict-variables": {
+      type: "boolean",
+      description: "Fail the render if any --variables key is undeclared or mistyped vs the composition's data-composition-variables. Without it, mismatches are warnings.",
+      default: false
+    },
+    batch: {
+      type: "string",
+      description: 'Path to a JSONL batch file for `render-batch`. Each line: {"outputKey":"...","variables":{...}}'
+    },
+    "max-concurrent": {
+      type: "string",
+      description: "Max in-flight executions for `render-batch` (default: 50)."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "For `render-batch`: parse the batch file and print the manifest without starting any execution.",
+      default: false
+    },
+    "render-id": {
+      type: "string",
+      description: "Client render id / GCS prefix (default: hf-render-<uuid>)"
+    },
+    "output-key": {
+      type: "string",
+      description: "Final output GCS key (default: renders/<renderId>/output.<ext>)"
+    },
+    wait: { type: "boolean", description: "Block until the render finishes" },
+    "wait-interval-ms": {
+      type: "string",
+      description: "Poll cadence in ms when --wait is set (default: 5000)"
+    },
+    json: { type: "boolean", description: "Emit machine-readable JSON" }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    const subcommand = args.subcommand;
+    if (!subcommand) {
+      console.log(HELP);
+      return;
+    }
+    const verbsNeedingAdapter = /* @__PURE__ */ new Set([
+      "deploy",
+      "sites",
+      "render",
+      "render-batch",
+      "progress",
+      "destroy"
+    ]);
+    if (verbsNeedingAdapter.has(subcommand)) {
+      try {
+        await loadCloudRunAdapter();
+      } catch (error) {
+        if (isMissingCloudRunAdapterError(error)) {
+          console.error(missingCloudRunAdapterMessage(subcommand));
+          failCommand();
+        }
+        throw error;
+      }
+    }
+    switch (subcommand) {
+      case "deploy":
+        return runDeploy(args);
+      case "sites":
+        return runSites(args);
+      case "render":
+        return runRender(args);
+      case "render-batch":
+        return runRenderBatch(args);
+      case "progress":
+        return runProgress(args);
+      case "destroy":
+        return runDestroy(args);
+      default:
+        console.error(`${c.error("Unknown subcommand:")} ${subcommand}
+${HELP}`);
+        failCommand();
+    }
+  }
+});
+function stateDir() {
+  return join(homedir(), ".hyperframes");
+}
+function statePath() {
+  return join(stateDir(), "cloudrun-state.json");
+}
+function writeState(state) {
+  mkdirSync(stateDir(), { recursive: true });
+  writeFileSync(statePath(), JSON.stringify(state, null, 2));
+}
+function readState(args) {
+  const overrides = {
+    projectId: args.project,
+    region: args.region
+  };
+  let base = {};
+  if (existsSync(statePath())) {
+    try {
+      base = JSON.parse(readFileSync(statePath(), "utf8"));
+    } catch {
+    }
+  }
+  const merged = { ...base, ...stripUndefined(overrides) };
+  const missing = ["projectId", "region", "bucketName", "serviceUrl", "workflowId"].filter((k) => !merged[k]);
+  if (missing.length > 0) {
+    console.error(
+      `[cloudrun] missing stack coordinates: ${missing.join(", ")}. Run \`framey cloudrun deploy --project <id>\` first, or pass them as flags.`
+    );
+    failCommand();
+  }
+  return merged;
+}
+function stripUndefined(o) {
+  return Object.fromEntries(Object.entries(o).filter(([, v]) => v != null));
+}
+function run(cmd, cmdArgs, opts = {}) {
+  const res = spawnSync(cmd, cmdArgs, { stdio: "inherit", cwd: opts.cwd });
+  if (res.status !== 0) {
+    throw new Error(`[cloudrun] \`${cmd} ${cmdArgs.join(" ")}\` exited with ${res.status}`);
+  }
+}
+function capture(cmd, cmdArgs, opts = {}) {
+  const res = spawnSync(cmd, cmdArgs, { encoding: "utf8", cwd: opts.cwd });
+  if (res.status !== 0) {
+    throw new Error(`[cloudrun] \`${cmd} ${cmdArgs.join(" ")}\` failed: ${res.stderr}`);
+  }
+  return res.stdout.trim();
+}
+async function runDeploy(args) {
+  const project = args.project;
+  if (!project) {
+    console.error("[cloudrun deploy] --project <gcp-project-id> is required.");
+    failCommand();
+  }
+  const region = args.region ?? "us-central1";
+  const repo = args.repo ?? "hyperframes";
+  const { getTerraformModuleDir } = await loadCloudRunAdapter();
+  const tfDir = getTerraformModuleDir();
+  const repoRoot = findRepoRoot(tfDir);
+  console.log(`\u2192 Enabling required APIs on ${project}`);
+  run("gcloud", [
+    "services",
+    "enable",
+    "run.googleapis.com",
+    "workflows.googleapis.com",
+    "workflowexecutions.googleapis.com",
+    "artifactregistry.googleapis.com",
+    "cloudbuild.googleapis.com",
+    "monitoring.googleapis.com",
+    "--project",
+    project
+  ]);
+  let image = args.image;
+  if (!image) {
+    if (!repoRoot) {
+      console.error(
+        "[cloudrun deploy] --image is required when not running from a hyperframes checkout (no Dockerfile context found)."
+      );
+      failCommand();
+    }
+    const exists = spawnSync("gcloud", [
+      "artifacts",
+      "repositories",
+      "describe",
+      repo,
+      "--location",
+      region,
+      "--project",
+      project
+    ]).status === 0;
+    if (!exists) {
+      run("gcloud", [
+        "artifacts",
+        "repositories",
+        "create",
+        repo,
+        "--repository-format",
+        "docker",
+        "--location",
+        region,
+        "--project",
+        project
+      ]);
+    }
+    const tag = (/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 14);
+    image = `${region}-docker.pkg.dev/${project}/${repo}/hyperframes-render:${tag}`;
+    console.log(`\u2192 Building + pushing ${image} via Cloud Build`);
+    run("gcloud", [
+      "builds",
+      "submit",
+      repoRoot,
+      "--project",
+      project,
+      "--timeout",
+      "3600s",
+      "--config",
+      writeCloudBuildConfig(image)
+    ]);
+  }
+  console.log("\u2192 terraform apply");
+  run("terraform", ["init", "-input=false"], { cwd: tfDir });
+  run(
+    "terraform",
+    ["apply", "-input=false", "-auto-approve", ...machineVars(args, project, region, image)],
+    { cwd: tfDir }
+  );
+  const state = {
+    projectId: project,
+    region,
+    bucketName: capture("terraform", ["output", "-raw", "render_bucket_name"], { cwd: tfDir }),
+    serviceUrl: capture("terraform", ["output", "-raw", "service_url"], { cwd: tfDir }),
+    workflowId: capture("terraform", ["output", "-raw", "workflow_name"], { cwd: tfDir })
+  };
+  writeState(state);
+  console.log(`${c.accent("\u2713 deployed.")} bucket=${state.bucketName} workflow=${state.workflowId}`);
+  console.log(`  service=${state.serviceUrl}`);
+  console.log(
+    `  Next: ${c.accent("framey cloudrun render ./my-project --width 1920 --height 1080 --wait")}`
+  );
+}
+function machineVars(args, project, region, image) {
+  const vars = [
+    "-var",
+    `project_id=${project}`,
+    "-var",
+    `region=${region}`,
+    "-var",
+    `image=${image}`
+  ];
+  const cpu = args.cpu;
+  const memory = args.memory;
+  const maxInstances = parsePositiveInt(args["max-instances"], "--max-instances");
+  const timeout = parsePositiveInt(args.timeout, "--timeout");
+  if (cpu) vars.push("-var", `cpu=${cpu}`);
+  if (memory) vars.push("-var", `memory=${memory}`);
+  if (maxInstances !== void 0) vars.push("-var", `max_instances=${maxInstances}`);
+  if (timeout !== void 0) vars.push("-var", `request_timeout_seconds=${timeout}`);
+  return vars;
+}
+function findRepoRoot(tfDir) {
+  const candidate = resolve(tfDir, "..", "..", "..");
+  if (existsSync(join(candidate, "packages", "gcp-cloud-run", "Dockerfile"))) return candidate;
+  return null;
+}
+function writeCloudBuildConfig(image) {
+  const cfgPath = join(stateDir(), "cloudrun-cloudbuild.yaml");
+  mkdirSync(stateDir(), { recursive: true });
+  writeFileSync(
+    cfgPath,
+    [
+      "steps:",
+      "- name: gcr.io/cloud-builders/docker",
+      `  args: ["build","-f","packages/gcp-cloud-run/Dockerfile","-t","${image}","."]`,
+      `images: ["${image}"]`,
+      "timeout: 3600s",
+      ""
+    ].join("\n")
+  );
+  return cfgPath;
+}
+async function runSites(args) {
+  if (args.target !== "create") {
+    console.error(
+      `[cloudrun sites] unknown verb "${String(args.target)}". Only "create" is supported.`
+    );
+    failCommand();
+  }
+  const projectDir = args.extra;
+  if (!projectDir) {
+    console.error("[cloudrun sites create] usage: framey cloudrun sites create <projectDir>");
+    failCommand();
+  }
+  const state = readState(args);
+  const { deploySite } = await loadCloudRunAdapter();
+  const handle = await deploySite({
+    projectDir: resolve(projectDir),
+    bucketName: state.bucketName,
+    siteId: args["site-id"]
+  });
+  if (args.json) {
+    console.log(JSON.stringify(handle, null, 2));
+  } else {
+    console.log(
+      `${handle.uploaded ? c.accent("\u2713 uploaded") : c.dim("\u2022 already present")} site=${handle.siteId} (${handle.bytes} bytes)
+  ${handle.projectGcsUri}`
+    );
+  }
+}
+function resolveCloudRunFps(args, projectDir, command) {
+  const fps = parseIntFlag(args.fps) ?? defaultCloudFps(projectDir);
+  if (isDistributedFps(fps)) return fps;
+  console.error(
+    `[cloudrun ${command}] --fps must be one of ${DISTRIBUTED_FPS.join(", ")}; got ${fps}.`
+  );
+  failCommand();
+}
+async function runRender(args) {
+  const projectDir = args.target;
+  if (!projectDir) {
+    console.error(
+      "[cloudrun render] usage: framey cloudrun render <projectDir> --width <px> --height <px>"
+    );
+    failCommand();
+  }
+  const width = parsePositiveInt(args.width, "--width");
+  const height = parsePositiveInt(args.height, "--height");
+  if (width === void 0 || height === void 0) {
+    console.error("[cloudrun render] --width and --height are required.");
+    failCommand();
+  }
+  const fps = resolveCloudRunFps(args, projectDir, "render");
+  const state = readState(args);
+  const variables = resolveAndValidateVariables(args, resolve(projectDir));
+  const config = buildRenderConfig(args, fps, width, height, variables);
+  const { renderToCloudRun, getRenderProgress } = await loadCloudRunAdapter();
+  const handle = await renderToCloudRun({
+    projectDir: resolve(projectDir),
+    config,
+    bucketName: state.bucketName,
+    projectId: state.projectId,
+    location: state.region,
+    workflowId: state.workflowId,
+    serviceUrl: state.serviceUrl,
+    renderId: args["render-id"],
+    outputKey: args["output-key"]
+  });
+  if (!args.wait) {
+    if (args.json) console.log(JSON.stringify(handle, null, 2));
+    else {
+      console.log(`${c.accent("\u2713 render started")} renderId=${handle.renderId}`);
+      console.log(`  output \u2192 ${handle.outputGcsUri}`);
+      console.log(`  progress: ${c.accent(`framey cloudrun progress ${handle.executionName}`)}`);
+    }
+    return;
+  }
+  const intervalMs = parsePositiveInt(args["wait-interval-ms"], "--wait-interval-ms") ?? 5e3;
+  let progress = await getRenderProgress({ executionName: handle.executionName });
+  while (progress.status === "running") {
+    await new Promise((r) => setTimeout(r, intervalMs));
+    progress = await getRenderProgress({ executionName: handle.executionName });
+    if (!args.json) process.stdout.write(`\r  status=${progress.status} `);
+  }
+  if (!args.json) process.stdout.write("\n");
+  if (args.json) {
+    console.log(JSON.stringify(progress, null, 2));
+  } else if (progress.status === "succeeded") {
+    console.log(
+      `${c.accent("\u2713 done.")} ${progress.outputFile?.gcsUri} (${progress.costs.displayCost})`
+    );
+  } else {
+    console.error(`${c.error("\u2717 render " + progress.status)}`);
+    for (const e of progress.errors) console.error(`  ${e.state}: ${e.cause}`);
+    failCommand();
+  }
+}
+async function runProgress(args) {
+  const executionName = args.target;
+  if (!executionName) {
+    console.error("[cloudrun progress] usage: framey cloudrun progress <executionName>");
+    failCommand();
+  }
+  const { getRenderProgress } = await loadCloudRunAdapter();
+  const progress = await getRenderProgress({ executionName });
+  if (args.json) {
+    console.log(JSON.stringify(progress, null, 2));
+    return;
+  }
+  console.log(`status=${progress.status} progress=${(progress.overallProgress * 100).toFixed(0)}%`);
+  if (progress.totalFrames)
+    console.log(`frames=${progress.framesRendered}/${progress.totalFrames}`);
+  if (progress.outputFile) console.log(`output=${progress.outputFile.gcsUri}`);
+  console.log(`cost=${progress.costs.displayCost}`);
+  for (const e of progress.errors) console.error(`  error ${e.state}: ${e.cause}`);
+}
+var DEFAULT_BATCH_MAX_CONCURRENT = 50;
+async function runRenderBatch(args) {
+  const projectDir = args.target;
+  const batchPath = args.batch;
+  if (!projectDir || !batchPath) {
+    console.error(
+      "[cloudrun render-batch] usage: framey cloudrun render-batch <projectDir> --batch <file.jsonl> --width <px> --height <px>"
+    );
+    failCommand();
+  }
+  const width = parsePositiveInt(args.width, "--width");
+  const height = parsePositiveInt(args.height, "--height");
+  if (width === void 0 || height === void 0) {
+    console.error("[cloudrun render-batch] --width and --height are required.");
+    failCommand();
+  }
+  const fps = resolveCloudRunFps(args, projectDir, "render-batch");
+  if (!existsSync(resolve(batchPath))) {
+    console.error(`[cloudrun render-batch] batch file not found: ${batchPath}`);
+    failCommand();
+  }
+  const entries = parseBatchFile(resolve(batchPath));
+  if (entries.length === 0) {
+    console.error("[cloudrun render-batch] batch file has no entries.");
+    failCommand();
+  }
+  const dryRun = Boolean(args["dry-run"]);
+  if (dryRun) {
+    const manifest = entries.map((e, i) => ({
+      line: i + 1,
+      outputKey: e.outputKey,
+      status: "would-start"
+    }));
+    console.log(JSON.stringify(manifest, null, 2));
+    return;
+  }
+  const state = readState(args);
+  const maxConcurrent = parsePositiveInt(args["max-concurrent"], "--max-concurrent") ?? DEFAULT_BATCH_MAX_CONCURRENT;
+  const { deploySite, renderToCloudRun } = await loadCloudRunAdapter();
+  const siteHandle = await deploySite({
+    projectDir: resolve(projectDir),
+    bucketName: state.bucketName,
+    siteId: args["site-id"]
+  });
+  const results = [];
+  for (let i = 0; i < entries.length; i += maxConcurrent) {
+    const wave = entries.slice(i, i + maxConcurrent);
+    const settled = await Promise.all(
+      wave.map(async (entry) => {
+        try {
+          const config = buildRenderConfig(args, fps, width, height, entry.variables);
+          const handle = await renderToCloudRun({
+            siteHandle,
+            config,
+            bucketName: state.bucketName,
+            projectId: state.projectId,
+            location: state.region,
+            workflowId: state.workflowId,
+            serviceUrl: state.serviceUrl,
+            outputKey: entry.outputKey
+          });
+          return { outputKey: entry.outputKey, executionName: handle.executionName };
+        } catch (err) {
+          return {
+            outputKey: entry.outputKey,
+            error: normalizeErrorMessage(err)
+          };
+        }
+      })
+    );
+    results.push(...settled);
+  }
+  const failed = results.filter((r) => r.error);
+  if (args.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    console.log(
+      `${c.accent("\u2713 started")} ${results.length - failed.length}/${results.length} renders`
+    );
+    for (const r of failed) console.error(`  \u2717 ${r.outputKey}: ${r.error}`);
+  }
+  if (failed.length > 0) failCommand();
+}
+function parseBatchFile(path) {
+  const lines = readFileSync(path, "utf8").split(/\r?\n/);
+  const entries = [];
+  lines.forEach((line, idx) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      console.error(`[cloudrun render-batch] line ${idx + 1}: not valid JSON`);
+      failCommand();
+    }
+    if (!parsed || typeof parsed !== "object" || typeof parsed.outputKey !== "string") {
+      console.error(
+        `[cloudrun render-batch] line ${idx + 1}: must be an object with a string "outputKey"`
+      );
+      failCommand();
+    }
+    entries.push(parsed);
+  });
+  return entries;
+}
+async function runDestroy(args) {
+  const { getTerraformModuleDir } = await loadCloudRunAdapter();
+  const tfDir = getTerraformModuleDir();
+  const state = existsSync(statePath()) ? JSON.parse(readFileSync(statePath(), "utf8")) : {};
+  const project = args.project ?? state.projectId;
+  const region = args.region ?? state.region ?? "us-central1";
+  const image = args.image ?? "unused:latest";
+  if (!project) {
+    console.error("[cloudrun destroy] --project is required (or deploy first to cache it).");
+    failCommand();
+  }
+  const vars = [
+    "-var",
+    `project_id=${project}`,
+    "-var",
+    `region=${region}`,
+    "-var",
+    `image=${image}`,
+    "-var",
+    "bucket_force_destroy=true"
+  ];
+  console.log("\u2192 terraform destroy");
+  run("terraform", ["init", "-input=false"], { cwd: tfDir });
+  try {
+    run("terraform", ["apply", "-input=false", "-auto-approve", ...vars], { cwd: tfDir });
+  } catch {
+  }
+  run("terraform", ["destroy", "-input=false", "-auto-approve", ...vars], { cwd: tfDir });
+  console.log(`${c.accent("\u2713 destroyed.")}`);
+}
+function buildRenderConfig(args, fps, width, height, variables) {
+  const { outputResolution, outputResolutionAspectAgnostic } = parseOutputResolution(
+    args["output-resolution"]
+  );
+  return stripUndefined({
+    fps,
+    width,
+    height,
+    format: parseFormat(args.format),
+    codec: parseCodec(args.codec),
+    quality: parseQuality(args.quality),
+    chunkSize: parsePositiveInt(args["chunk-size"], "--chunk-size"),
+    maxParallelChunks: parsePositiveInt(args["max-parallel-chunks"], "--max-parallel-chunks"),
+    targetChunkFrames: parsePositiveInt(args["target-chunk-frames"], "--target-chunk-frames"),
+    outputResolution,
+    // Set only when true so the wire shape stays sparse for the common
+    // canonical-preset path (matches how the flag flows through
+    // `SerializableDistributedRenderConfig` from every other emitter).
+    outputResolutionAspectAgnostic: outputResolutionAspectAgnostic ? true : void 0,
+    variables
+  });
+}
+function resolveAndValidateVariables(args, projectDir) {
+  const variables = resolveVariablesArg(
+    args.variables,
+    args["variables-file"]
+  );
+  if (variables && Object.keys(variables).length > 0) {
+    const indexPath = join(projectDir, "index.html");
+    if (existsSync(indexPath)) {
+      const issues = validateVariablesAgainstProject(indexPath, variables);
+      reportVariableIssues(issues, {
+        strict: Boolean(args["strict-variables"]),
+        quiet: Boolean(args.json)
+      });
+    }
+  }
+  return variables;
+}
+function parseOutputResolution(raw) {
+  return parseOutputResolutionFlag(raw, { surfaceLabel: "[cloudrun render]" });
+}
+function parseIntFlag(raw) {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  const n = Number.parseInt(String(raw), 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parsePositiveInt(raw, flagName) {
+  const n = parseIntFlag(raw);
+  if (n === void 0) return void 0;
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`[cloudrun] ${flagName} must be a positive integer; got ${n}`);
+  }
+  return n;
+}
+function parseEnum(raw, allowed, errorPrefix, defaultValue) {
+  if (raw === void 0 || raw === null || raw === "") return defaultValue;
+  const s = String(raw);
+  if (allowed.includes(s)) return s;
+  throw new Error(`${errorPrefix} must be ${allowed.join("|")}; got ${s}`);
+}
+var FORMATS = ["mp4", "mov", "png-sequence", "webm"];
+var CODECS = ["h264", "h265"];
+var QUALITIES = ["draft", "standard", "high"];
+var parseFormat = (raw) => parseEnum(raw, FORMATS, "[cloudrun render] --format", "mp4");
+var parseCodec = (raw) => parseEnum(raw, CODECS, "[cloudrun render] --codec", void 0);
+var parseQuality = (raw) => parseEnum(raw, QUALITIES, "[cloudrun render] --quality", void 0);
+export {
+  buildRenderConfig,
+  cloudrun_default as default,
+  examples,
+  isMissingCloudRunAdapterError,
+  missingCloudRunAdapterMessage
+};