@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/producer-SKU5EV3J.js

@@ -0,0 +1,13 @@
+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 {
+  loadProducer
+} from "./chunk-PURHAXFL.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  loadProducer
+};

package/vendor/framey/dist/progress-ZWB4Z4ET.js

@@ -0,0 +1,76 @@
+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 {
+  requireStack,
+  videoArchitecture
+} from "./chunk-3FYD4YEK.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/progress.ts
+async function runProgress(args) {
+  const stack = requireStack(args.stackName);
+  const executionArn = args.target.startsWith("arn:") ? args.target : executionArnFromName(stack.stateMachineArn, args.target);
+  const { getRenderProgress } = await import("@framey/aws-lambda/sdk");
+  const progress = await getRenderProgress({
+    executionArn,
+    region: stack.region,
+    defaultMemorySizeMb: stack.lambdaMemoryMb,
+    videoArchitecture: videoArchitecture(stack)
+  });
+  if (args.json) {
+    console.log(JSON.stringify(progress, null, 2));
+    return;
+  }
+  for (const warning of progress.warnings) console.warn(c.warn(warning));
+  const pct = Math.round(progress.overallProgress * 100);
+  console.log(`${c.dim("Status:")}    ${statusColor(progress.status)}`);
+  console.log(`${c.dim("Progress:")}  ${pct}%`);
+  console.log(
+    `${c.dim("Frames:")}    ${progress.framesRendered}${progress.totalFrames === null ? "" : ` / ${progress.totalFrames}`}`
+  );
+  console.log(`${c.dim("Lambdas:")}   ${progress.lambdasInvoked}`);
+  console.log(
+    `${c.dim("Cost:")}      ${progress.costs.displayCost} (Lambda $${progress.costs.breakdown.lambdaUsd.toFixed(4)} + SFN $${progress.costs.breakdown.stepFunctionsUsd.toFixed(4)})`
+  );
+  if (progress.outputFile) {
+    console.log(`${c.dim("Output:")}    ${progress.outputFile.s3Uri}`);
+  }
+  if (progress.errors.length > 0) {
+    console.log();
+    console.log(c.error("Errors:"));
+    for (const err of progress.errors) {
+      console.log(`  ${c.dim(err.state)}: ${err.error} \u2014 ${err.cause}`);
+    }
+  }
+  if (progress.fatalErrorEncountered) {
+    setCommandExitCode(1);
+  }
+}
+function executionArnFromName(stateMachineArn, name) {
+  return stateMachineArn.replace(":stateMachine:", ":execution:") + `:${name}`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "SUCCEEDED":
+      return c.success(status);
+    case "FAILED":
+    case "TIMED_OUT":
+    case "ABORTED":
+      return c.error(status);
+    default:
+      return status;
+  }
+}
+export {
+  runProgress
+};

package/vendor/framey/dist/projectConfig-3MZAYVTS.js

@@ -0,0 +1,60 @@
+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 {
+  DEFAULT_PROJECT_CONFIG,
+  PROJECT_CONFIG_FILENAME,
+  createProjectConfig,
+  loadProjectConfig,
+  normalizeConfig,
+  projectConfigPath,
+  readProjectConfig,
+  readProjectConfigWithStatus,
+  recordProjectRegistryItems,
+  resolveAutoProxy,
+  seedProjectAuthoringSkill,
+  writeProjectConfig
+} from "./chunk-4BNN5FGX.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-XX7LTW5Y.js";
+import "./chunk-JHOCK3DG.js";
+import "./chunk-XPTOJZJF.js";
+import "./chunk-RGLQURIX.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./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 "./chunk-PKZ7RK5N.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";
+export {
+  DEFAULT_PROJECT_CONFIG,
+  PROJECT_CONFIG_FILENAME,
+  createProjectConfig,
+  loadProjectConfig,
+  normalizeConfig,
+  projectConfigPath,
+  readProjectConfig,
+  readProjectConfigWithStatus,
+  recordProjectRegistryItems,
+  resolveAutoProxy,
+  seedProjectAuthoringSkill,
+  writeProjectConfig
+};

package/vendor/framey/dist/publication-DTKWNF74.js

@@ -0,0 +1,33 @@
+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 {
+  publishRegistryFile,
+  registryTargetPath
+} from "./chunk-GMECXFAN.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import {
+  realProjectRoot
+} from "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.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";
+export {
+  publishRegistryFile,
+  realProjectRoot as registryRoot,
+  registryTargetPath
+};

package/vendor/framey/dist/remove-background-OY5L7XN2.js

@@ -0,0 +1,265 @@
+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 {
+  RemoveBackgroundError,
+  removeBackground
+} from "./chunk-FV3PIKGH.js";
+import {
+  DEFAULT_MODEL,
+  DEFAULT_QUALITY,
+  DEVICES,
+  MODEL_MEMORY_MB,
+  QUALITIES,
+  isDevice,
+  isQuality,
+  listAvailableProviders,
+  modelPath,
+  selectProviders
+} from "./chunk-YCMVI4MZ.js";
+import "./chunk-VMC4WSH5.js";
+import "./chunk-6BEFEWFB.js";
+import "./chunk-WQ6ZXHFQ.js";
+import "./chunk-UMD3V7CU.js";
+import {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-TIQB63MX.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNV3DM4S.js";
+import "./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 "./chunk-BL4U6U52.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/remove-background.ts
+import { existsSync } from "fs";
+var examples = [
+  [
+    "Remove background from a video, output transparent VP9 WebM (default)",
+    "framey remove-background avatar.mp4 -o transparent.webm"
+  ],
+  [
+    "Output ProRes 4444 .mov for editing round-trip",
+    "framey remove-background avatar.mp4 -o transparent.mov"
+  ],
+  [
+    "Remove background from a single image, output transparent PNG",
+    "framey remove-background portrait.jpg -o cutout.png"
+  ],
+  [
+    "Separate the layers \u2014 emit both the cutout and an inverse-alpha background plate (subject region transparent)",
+    "framey remove-background avatar.mp4 -o subject.webm --background-output plate.webm"
+  ],
+  [
+    "Force CPU (skip CoreML/CUDA)",
+    "framey remove-background avatar.mp4 -o transparent.webm --device cpu"
+  ],
+  [
+    "Smaller file at the cost of color match (text-behind-subject won't blend as cleanly)",
+    "framey remove-background avatar.mp4 -o transparent.webm --quality fast"
+  ],
+  [
+    "Visually-lossless WebM (master / re-encode source)",
+    "framey remove-background avatar.mp4 -o transparent.webm --quality best"
+  ],
+  ["Show detected providers without rendering", "framey remove-background --info"]
+];
+var remove_background_default = defineCommand({
+  meta: {
+    name: "remove-background",
+    description: "Remove background from a video or image using a local AI model \u2014 outputs transparent WebM, ProRes 4444, or PNG"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Source video (.mp4/.mov/.webm/.mkv) or image (.jpg/.png/.webp)",
+      required: false
+    },
+    output: {
+      type: "string",
+      description: "Output path. Format inferred from extension: .webm (default), .mov, .png",
+      alias: "o"
+    },
+    "background-output": {
+      type: "string",
+      description: "Optional second output path for the inverse-alpha background plate (subject region transparent, original surroundings opaque). Hole-cut, not inpainted \u2014 composite something underneath to fill the hole. Must be .webm or .mov; not allowed for image inputs.",
+      alias: "b"
+    },
+    device: {
+      type: "string",
+      description: `Execution provider: ${DEVICES.join(", ")}`,
+      default: "auto"
+    },
+    quality: {
+      type: "string",
+      description: `Encoder quality preset for .webm output: ${QUALITIES.join(", ")} (default: ${DEFAULT_QUALITY}). Higher quality = closer color match when overlaying on the source mp4, larger file. Ignored for .mov / .png.`,
+      default: DEFAULT_QUALITY
+    },
+    info: {
+      type: "boolean",
+      description: "Print detected execution providers and exit (no render)",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (args.info) {
+      return showInfo(args.json);
+    }
+    if (!args.input) {
+      console.error(
+        c.error("Input file is required. Run `framey remove-background --info` for providers.")
+      );
+      failCommand();
+    }
+    if (!args.output) {
+      console.error(c.error("--output (-o) is required. Use a .webm, .mov, or .png path."));
+      failCommand();
+    }
+    if (!isDevice(args.device)) {
+      console.error(
+        c.error(`Invalid --device '${String(args.device)}'. Use: ${DEVICES.join(", ")}.`)
+      );
+      failCommand();
+    }
+    if (!isQuality(args.quality)) {
+      console.error(
+        c.error(`Invalid --quality '${String(args.quality)}'. Use: ${QUALITIES.join(", ")}.`)
+      );
+      failCommand();
+    }
+    const spin = args.json ? null : ft();
+    spin?.start("Preparing background-removal pipeline...");
+    try {
+      const result = await removeBackground({
+        input: args.input,
+        output: args.output,
+        backgroundOutput: args["background-output"],
+        device: args.device,
+        quality: args.quality,
+        onProgress: (event) => {
+          if (event.kind === "info") {
+            spin?.message(event.message);
+          } else if (event.kind === "metadata") {
+            const dims = `${event.width}\xD7${event.height}`;
+            const frames = event.frameCount ? ` \xB7 ${event.frameCount} frames` : "";
+            spin?.message(`Source ${dims} @ ${event.fps.toFixed(0)}fps${frames}`);
+          } else if (event.kind === "frame") {
+            const pct = event.total ? ` (${Math.floor(100 * event.index / event.total)}%)` : "";
+            spin?.message(
+              `Frame ${event.index}${event.total ? `/${event.total}` : ""}${pct} \u2014 ${Math.round(event.avgMsPerFrame)}ms/frame avg`
+            );
+          }
+        }
+      });
+      if (args.json) {
+        console.log(
+          JSON.stringify({
+            ok: true,
+            outputPath: result.outputPath,
+            ...result.backgroundOutputPath ? { backgroundOutputPath: result.backgroundOutputPath } : {},
+            framesProcessed: result.framesProcessed,
+            durationSeconds: Number(result.durationSeconds.toFixed(2)),
+            avgMsPerFrame: Number(result.avgMsPerFrame.toFixed(1)),
+            provider: result.provider,
+            format: result.format
+          })
+        );
+      } else {
+        const fpsThroughput = result.durationSeconds ? (result.framesProcessed / result.durationSeconds).toFixed(1) : "n/a";
+        const outputs = result.backgroundOutputPath ? `${c.accent(result.outputPath)} + ${c.accent(result.backgroundOutputPath)}` : c.accent(result.outputPath);
+        spin?.stop(
+          c.success(
+            `Removed background from ${c.accent(String(result.framesProcessed))} frames in ${result.durationSeconds.toFixed(1)}s (${fpsThroughput} fps, ${c.accent(result.provider)}) \u2192 ${outputs}`
+          )
+        );
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (args.json) {
+        console.log(JSON.stringify({ ok: false, error: message }));
+      } else {
+        spin?.stop(c.error(`Background removal failed: ${message}`));
+      }
+      failCommand(1, pipelineError(err));
+    }
+  }
+});
+function pipelineError(err) {
+  return err instanceof RemoveBackgroundError ? err.cause : err;
+}
+async function showInfo(json) {
+  const providers = listAvailableProviders();
+  const auto = selectProviders("auto");
+  const cached = existsSync(modelPath());
+  if (json) {
+    console.log(
+      JSON.stringify({
+        defaultModel: DEFAULT_MODEL,
+        modelCached: cached,
+        modelPath: modelPath(),
+        peakMemoryMb: MODEL_MEMORY_MB[DEFAULT_MODEL],
+        availableProviders: providers,
+        autoProvider: auto.label
+      })
+    );
+    return;
+  }
+  console.log(c.bold("framey remove-background \u2014 system info"));
+  console.log("");
+  console.log(`  ${c.dim("Default model:")}     ${c.accent(DEFAULT_MODEL)}`);
+  console.log(`  ${c.dim("Peak memory:")}       ~${MODEL_MEMORY_MB[DEFAULT_MODEL]} MB`);
+  console.log(
+    `  ${c.dim("Weights cached:")}    ${cached ? c.success("yes") : c.dim("no (will download on first run)")}`
+  );
+  console.log(`  ${c.dim("Cache path:")}        ${modelPath()}`);
+  console.log("");
+  console.log(`  ${c.dim("Available providers:")} ${providers.join(", ")}`);
+  console.log(`  ${c.dim("Auto-selected:")}      ${c.accent(auto.label)}`);
+}
+export {
+  remove_background_default as default,
+  examples
+};

package/vendor/framey/dist/render-CDV4GDFX.js

@@ -0,0 +1,187 @@
+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 {
+  warnOnDimensionMismatch
+} from "./chunk-H6IEMZEV.js";
+import {
+  requireStack,
+  stateFilePath,
+  videoArchitecture
+} from "./chunk-3FYD4YEK.js";
+import {
+  reportVariableIssues,
+  resolveVariablesArg,
+  validateVariablesAgainstProject
+} from "./chunk-EAMLBAHA.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-LEKZNRKI.js";
+import "./chunk-442JNXRM.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import "./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 "./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/lambda/render.ts
+import { existsSync } from "fs";
+import { join, resolve as resolvePath } from "path";
+async function loadSDK() {
+  return import("@framey/aws-lambda/sdk");
+}
+async function runRender(args) {
+  const stack = requireStack(args.stackName);
+  const projectDir = resolvePath(args.projectDir);
+  warnOnDimensionMismatch({
+    projectDir,
+    cliWidth: args.width,
+    cliHeight: args.height,
+    outputResolution: args.outputResolution,
+    quiet: args.json
+  });
+  const variables = resolveVariablesArg(args.variables, args.variablesFile);
+  if (variables && Object.keys(variables).length > 0) {
+    const indexPath = join(projectDir, "index.html");
+    if (existsSync(indexPath)) {
+      const issues = validateVariablesAgainstProject(indexPath, variables);
+      reportVariableIssues(issues, { strict: args.strictVariables ?? false, quiet: args.json });
+    } else if (args.strictVariables && !args.json) {
+      console.warn(
+        c.warn(
+          `--strict-variables: no ${indexPath} on disk \u2014 schema validation skipped. Variables flow through unchecked. To enable strict checking, run from a project dir that contains the composition.`
+        )
+      );
+    }
+  }
+  const config = buildLambdaRenderConfig(
+    args,
+    variables,
+    stack.reservedConcurrency
+  );
+  const { renderToLambda, siteHandleFromId } = await loadSDK();
+  const siteHandle = args.siteId ? siteHandleFromId(stack.bucketName, args.siteId) : void 0;
+  const handle = await renderToLambda({
+    projectDir,
+    siteHandle,
+    bucketName: stack.bucketName,
+    stateMachineArn: stack.stateMachineArn,
+    region: stack.region,
+    config,
+    executionName: args.executionName,
+    outputKey: args.outputKey,
+    onNotice: (message) => console.error(c.dim(message))
+  });
+  if (args.json) {
+    if (args.wait) {
+      await waitForCompletion(handle.executionArn, stack, args.waitIntervalMs, args.json);
+    } else {
+      console.log(JSON.stringify(handle, null, 2));
+    }
+    return;
+  }
+  console.log(c.success("Render started."));
+  console.log(`  ${c.dim("Render ID:")}     ${handle.renderId}`);
+  console.log(`  ${c.dim("Execution ARN:")} ${handle.executionArn}`);
+  console.log(`  ${c.dim("Output S3 URI:")} ${handle.outputS3Uri}`);
+  console.log(`  ${c.dim("Project S3:")}    ${handle.projectS3Uri}`);
+  console.log(`  ${c.dim("Stack state:")}   ${stateFilePath(args.stackName)}`);
+  console.log();
+  if (args.wait) {
+    await waitForCompletion(handle.executionArn, stack, args.waitIntervalMs, args.json);
+    return;
+  }
+  console.log(c.dim(`Poll with: framey lambda progress ${handle.renderId}`));
+}
+async function waitForCompletion(executionArn, stack, intervalMs, json) {
+  const { getRenderProgress } = await loadSDK();
+  let lastRendered = -1;
+  const warned = /* @__PURE__ */ new Set();
+  while (true) {
+    const progress = await getRenderProgress({
+      executionArn,
+      region: stack.region,
+      defaultMemorySizeMb: stack.lambdaMemoryMb,
+      videoArchitecture: videoArchitecture(stack)
+    });
+    for (const warning of progress.warnings) {
+      if (!warned.has(warning)) console.warn(c.warn(warning));
+      warned.add(warning);
+    }
+    if (!json && progress.framesRendered !== lastRendered) {
+      lastRendered = progress.framesRendered;
+      const total = progress.totalFrames ?? "?";
+      const pct = Math.round(progress.overallProgress * 100);
+      console.log(
+        `  ${c.dim(`[${progress.status}]`)} ${pct}% \u2022 ${progress.framesRendered}/${total} frames \u2022 ${progress.costs.displayCost}`
+      );
+    }
+    if (progress.status !== "RUNNING") {
+      if (json) {
+        console.log(JSON.stringify(progress, null, 2));
+      } else if (progress.status === "SUCCEEDED" && progress.outputFile) {
+        console.log();
+        console.log(c.success("Render complete."));
+        console.log(`  ${c.dim("Output:")}        ${progress.outputFile.s3Uri}`);
+        console.log(`  ${c.dim("Size:")}          ${progress.outputFile.bytes ?? "?"} bytes`);
+        console.log(`  ${c.dim("Total cost:")}    ${progress.costs.displayCost}`);
+      } else {
+        console.log();
+        console.log(c.error(`Render ended with status ${progress.status}.`));
+        for (const err of progress.errors) {
+          console.log(`  ${c.dim(err.state)}: ${err.error} \u2014 ${err.cause}`);
+        }
+        setCommandExitCode(1);
+      }
+      return;
+    }
+    await sleep(intervalMs);
+  }
+}
+function sleep(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+function buildLambdaRenderConfig(args, variables, workerConcurrency) {
+  const config = {
+    fps: args.fps,
+    width: args.width,
+    height: args.height,
+    outputResolution: args.outputResolution,
+    format: args.format,
+    codec: args.codec,
+    quality: args.quality,
+    chunkSize: args.chunkSize,
+    maxParallelChunks: args.maxParallelChunks,
+    targetChunkFrames: args.targetChunkFrames,
+    workerConcurrency,
+    runtimeCap: "lambda",
+    variables
+  };
+  if (args.outputResolutionAspectAgnostic) {
+    config.outputResolutionAspectAgnostic = true;
+  }
+  return config;
+}
+export {
+  buildLambdaRenderConfig,
+  runRender
+};