@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/lambda-A7JC74JF.js

@@ -0,0 +1,468 @@
+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 {
+  defaultCloudFps
+} from "./chunk-KXTKKBOC.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 "./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.ts
+var examples = [
+  ["Deploy the Lambda render stack to AWS", "framey lambda deploy"],
+  [
+    "Render a composition on the deployed stack",
+    "framey lambda render ./my-project --width 1920 --height 1080"
+  ],
+  [
+    "Render and stream progress until done",
+    "framey lambda render ./my-project --width 1920 --height 1080 --wait"
+  ],
+  [
+    "Supersample a 1080p composition to 4K via Chrome deviceScaleFactor",
+    "framey lambda render ./my-project --width 1920 --height 1080 --output-resolution 4k --wait"
+  ],
+  [
+    "Render with composition variables (personalised template)",
+    `framey lambda render ./my-template --site-id abc1234deadbeef0 --width 1920 --height 1080 --variables '{"title":"Hello Alice","accent":"#ff0000"}'`
+  ],
+  [
+    "Render with variables from a JSON file",
+    "framey lambda render ./my-template --site-id abc1234deadbeef0 --width 1920 --height 1080 --variables-file ./alice.json"
+  ],
+  [
+    "Batch-render N personalised videos from a JSONL file (deploys the site once)",
+    "framey lambda render-batch ./my-template --batch ./users.jsonl --width 1920 --height 1080 --max-concurrent 10"
+  ],
+  ["Check progress for a started render", "framey lambda progress hf-render-abcd1234"],
+  [
+    "Pre-upload a project so multiple renders share the upload",
+    "framey lambda sites create ./my-project"
+  ],
+  ["Tear the stack down", "framey lambda destroy"],
+  ["Print the IAM policy the CLI needs", "framey lambda policies user"],
+  [
+    "Validate a checked-in IAM policy still covers the CLI",
+    "hyperframes lambda policies validate ./infra/iam/hyperframes.json"
+  ]
+];
+var HELP = `
+${c.bold("framey lambda")} ${c.dim("<subcommand> [args]")}
+
+Deploy + drive distributed video renders on AWS Lambda.
+
+${c.bold("SUBCOMMANDS:")}
+  ${c.accent("deploy")}            ${c.dim("Provision the Lambda + Step Functions + S3 stack via SAM")}
+  ${c.accent("sites create")}      ${c.dim("Tar + upload a project to S3 (reusable across renders)")}
+  ${c.accent("render")}            ${c.dim("Start a distributed render (returns a renderId)")}
+  ${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 (S3 bucket is retained)")}
+  ${c.accent("policies")}          ${c.dim("Print or validate the IAM permissions the CLI needs")}
+
+${c.bold("FIRST RUN:")}
+  ${c.accent("framey lambda deploy")}
+  ${c.accent("framey lambda render ./my-project --width 1920 --height 1080 --wait")}
+
+${c.bold("REQUIREMENTS:")}
+  \u2022 AWS CLI configured (env vars, ~/.aws/credentials, or SSO)
+  \u2022 AWS SAM CLI installed (https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+  \u2022 bun on PATH (used to build the handler ZIP)
+`;
+var lambda_default = defineCommand({
+  meta: { name: "lambda", description: "Deploy and drive renders on AWS Lambda" },
+  args: {
+    subcommand: {
+      type: "positional",
+      required: false,
+      description: "deploy | sites | render | progress | destroy | policies"
+    },
+    target: {
+      type: "positional",
+      required: false,
+      description: "Subcommand-specific positional (project dir, render id, policies verb, etc.)"
+    },
+    extra: {
+      type: "positional",
+      required: false,
+      description: "Extra positional (e.g. `sites create <projectDir>` or `policies validate <policy.json>`)"
+    },
+    // Stack identity
+    "stack-name": {
+      type: "string",
+      description: "CloudFormation stack name (default: hyperframes-default)"
+    },
+    region: { type: "string", description: "AWS region (default: AWS_REGION env or us-east-1)" },
+    profile: { type: "string", description: "AWS profile name (default: AWS_PROFILE env)" },
+    // deploy
+    concurrency: {
+      type: "string",
+      description: "Lambda reserved concurrency, or none to remove it (default: keep the stack's; a new stack reserves none and each render runs up to 90% of the account's unreserved concurrency)"
+    },
+    "chrome-source": {
+      type: "string",
+      description: "sparticuz | chrome-headless-shell (default: sparticuz)"
+    },
+    memory: { type: "string", description: "Lambda memory MB (default: 10240)" },
+    "video-arch": {
+      type: "string",
+      description: "arm64 | x86_64: where the plan and chunks run; arm64 adds a container-image function (default: arm64)"
+    },
+    "skip-build": { type: "boolean", description: "Reuse existing handler.zip (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" },
+    "output-resolution": {
+      type: "string",
+      description: "Output resolution preset that engages Chrome deviceScaleFactor supersampling. Accepts canonical names (landscape, landscape-4k, portrait, portrait-4k, square, square-4k) and aliases (1080p, 4k, uhd, hd). When set, the composition's authored data-width/data-height is supersampled to the target preset without changing the layout."
+    },
+    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 (default: sized so each chunk fits the Lambda timeout, one wave across --concurrency)"
+    },
+    "max-parallel-chunks": {
+      type: "string",
+      description: "Max chunks per render (default: one wave across the deploy's --concurrency, widened to fit the Lambda timeout)"
+    },
+    "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."
+    },
+    "execution-name": {
+      type: "string",
+      description: "Step Functions execution name (default: hf-render-<uuid>)"
+    },
+    "output-key": {
+      type: "string",
+      description: "Final output S3 key (default: renders/<exec>/output.<ext>)"
+    },
+    // Variables — mirrors the local `framey render` UX. Inline JSON or
+    // file path, plus --strict-variables for type-checked validation against
+    // the composition's `data-composition-variables` declaration.
+    variables: {
+      type: "string",
+      description: `JSON object of variable values for the composition. Example: --variables '{"title":"Hello"}'. Values flow into window.__hfVariables on the Lambda chunk workers.`
+    },
+    "variables-file": {
+      type: "string",
+      description: "Path to a JSON file with variable values (alternative to --variables). The file must contain a single JSON object."
+    },
+    "strict-variables": {
+      type: "boolean",
+      description: "Fail the render command if any --variables key is undeclared or has a wrong type vs the composition's data-composition-variables. Without this flag, mismatches are warnings.",
+      default: false
+    },
+    // render-batch
+    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 Step Functions executions for `render-batch` (default: 50). Distinct from --max-parallel-chunks (which caps chunks per render)."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "For `render-batch`: parse the batch file and print the manifest without invoking AWS. Every entry's status becomes `would-invoke`.",
+      default: false
+    },
+    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)"
+    },
+    // shared
+    json: { type: "boolean", description: "Emit machine-readable JSON" }
+  },
+  async run({ args }) {
+    const subcommand = args.subcommand;
+    if (!subcommand) {
+      console.log(HELP);
+      return;
+    }
+    const stackName = args["stack-name"] ?? // Lazy-imported so the dispatcher doesn't pull state.ts (and its
+    // node:fs deps) on every CLI invocation — only on lambda runs.
+    (await import("./state-B6H3WHCF.js")).DEFAULT_STACK_NAME;
+    const profileFlag = args.profile;
+    if (profileFlag) process.env.AWS_PROFILE = profileFlag;
+    const regionFlag = args.region;
+    if (regionFlag) process.env.AWS_REGION = regionFlag;
+    const verbsNeedingSDK = /* @__PURE__ */ new Set(["sites", "render", "render-batch", "progress"]);
+    if (verbsNeedingSDK.has(subcommand)) {
+      try {
+        await import("@framey/aws-lambda/sdk");
+      } catch (err) {
+        if (isMissingPackageError(err, "@framey/aws-lambda")) {
+          console.error(missingPackageMessage("@framey/aws-lambda", `framey lambda ${subcommand}`));
+          failCommand();
+        }
+        throw err;
+      }
+    }
+    switch (subcommand) {
+      case "deploy": {
+        const { runDeploy } = await import("./deploy-6FJPWKF2.js");
+        const { parseReservedConcurrency } = await import("./sam-WFZXI4F7.js");
+        await runDeploy({
+          stackName,
+          region: args.region,
+          awsProfile: args.profile,
+          reservedConcurrency: parseReservedConcurrency(args.concurrency),
+          chromeSource: parseChromeSource(args["chrome-source"]),
+          lambdaMemoryMb: parsePositiveInt(args.memory, "--memory"),
+          videoArch: parseVideoArch(args["video-arch"]),
+          skipBuild: Boolean(args["skip-build"])
+        });
+        return;
+      }
+      case "sites": {
+        if (args.target !== "create") {
+          console.error(
+            `[lambda sites] unknown verb "${String(args.target)}". Only "create" is supported.`
+          );
+          failCommand();
+        }
+        const projectDir = args.extra;
+        if (!projectDir) {
+          console.error("[lambda sites create] usage: framey lambda sites create <projectDir>");
+          failCommand();
+        }
+        const { runSitesCreate } = await import("./sites-AMOVABTK.js");
+        await runSitesCreate({
+          projectDir,
+          stackName,
+          siteId: args["site-id"],
+          json: Boolean(args.json)
+        });
+        return;
+      }
+      case "render": {
+        const projectDir = args.target;
+        if (!projectDir) {
+          console.error(
+            "[lambda render] usage: framey lambda 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("[lambda render] --width and --height are required.");
+          failCommand();
+        }
+        const fpsRaw = parseIntFlag(args.fps) ?? defaultCloudFps(projectDir);
+        if (!isDistributedFps(fpsRaw)) {
+          console.error(
+            `[lambda render] --fps must be one of ${DISTRIBUTED_FPS.join(", ")}; got ${fpsRaw}.`
+          );
+          failCommand();
+        }
+        const { runRender } = await import("./render-CDV4GDFX.js");
+        const renderResolution = parseOutputResolution(args["output-resolution"]);
+        await runRender({
+          projectDir,
+          stackName,
+          siteId: args["site-id"],
+          fps: fpsRaw,
+          width,
+          height,
+          outputResolution: renderResolution.outputResolution,
+          outputResolutionAspectAgnostic: renderResolution.outputResolutionAspectAgnostic,
+          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"),
+          executionName: args["execution-name"],
+          outputKey: args["output-key"],
+          variables: args.variables,
+          variablesFile: args["variables-file"],
+          strictVariables: Boolean(args["strict-variables"]),
+          json: Boolean(args.json),
+          wait: Boolean(args.wait),
+          waitIntervalMs: parsePositiveInt(args["wait-interval-ms"], "--wait-interval-ms") ?? 5e3
+        });
+        return;
+      }
+      case "render-batch": {
+        const projectDir = args.target;
+        if (!projectDir) {
+          console.error(
+            "[lambda render-batch] usage: framey lambda render-batch <projectDir> --batch <path.jsonl> --width <px> --height <px>"
+          );
+          failCommand();
+        }
+        const batch = args.batch;
+        if (!batch) {
+          console.error(
+            "[lambda render-batch] --batch <path.jsonl> is required. Each line is a JSON object with at least { outputKey: '...' }."
+          );
+          failCommand();
+        }
+        const width = parsePositiveInt(args.width, "--width");
+        const height = parsePositiveInt(args.height, "--height");
+        if (width === void 0 || height === void 0) {
+          console.error("[lambda render-batch] --width and --height are required.");
+          failCommand();
+        }
+        const fpsRaw = parseIntFlag(args.fps) ?? defaultCloudFps(projectDir);
+        if (!isDistributedFps(fpsRaw)) {
+          console.error(
+            `[lambda render-batch] --fps must be one of ${DISTRIBUTED_FPS.join(", ")}; got ${fpsRaw}.`
+          );
+          failCommand();
+        }
+        const { runRenderBatch } = await import("./render-batch-ZAMFPCLL.js");
+        const batchResolution = parseOutputResolution(args["output-resolution"]);
+        await runRenderBatch({
+          projectDir,
+          stackName,
+          batch,
+          siteId: args["site-id"],
+          fps: fpsRaw,
+          width,
+          height,
+          outputResolution: batchResolution.outputResolution,
+          outputResolutionAspectAgnostic: batchResolution.outputResolutionAspectAgnostic,
+          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"),
+          maxConcurrent: parsePositiveInt(args["max-concurrent"], "--max-concurrent"),
+          strictVariables: Boolean(args["strict-variables"]),
+          dryRun: Boolean(args["dry-run"]),
+          json: Boolean(args.json)
+        });
+        return;
+      }
+      case "progress": {
+        const target = args.target;
+        if (!target) {
+          console.error(
+            "[lambda progress] usage: framey lambda progress <renderId | executionArn>"
+          );
+          failCommand();
+        }
+        const { runProgress } = await import("./progress-ZWB4Z4ET.js");
+        await runProgress({ target, stackName, json: Boolean(args.json) });
+        return;
+      }
+      case "destroy": {
+        const { runDestroy } = await import("./destroy-HE2RIPKZ.js");
+        await runDestroy({ stackName, awsProfile: args.profile });
+        return;
+      }
+      case "policies": {
+        const verb = args.target;
+        if (verb !== "role" && verb !== "user" && verb !== "validate") {
+          console.error(
+            `[lambda policies] usage: framey lambda policies <role|user|validate> [args]`
+          );
+          failCommand();
+        }
+        const { runPolicies } = await import("./policies-OLDYGFK5.js");
+        await runPolicies({
+          verb,
+          inputPath: args.extra,
+          json: Boolean(args.json)
+        });
+        return;
+      }
+      default:
+        console.error(`${c.error("Unknown subcommand:")} ${subcommand}
+${HELP}`);
+        failCommand();
+    }
+  }
+});
+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(`[lambda] ${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 CHROME_SOURCES = ["sparticuz", "chrome-headless-shell"];
+var parseFormat = (raw) => parseEnum(raw, FORMATS, "[lambda render] --format", "mp4");
+var parseCodec = (raw) => parseEnum(raw, CODECS, "[lambda render] --codec", void 0);
+var parseQuality = (raw) => parseEnum(raw, QUALITIES, "[lambda render] --quality", void 0);
+var parseChromeSource = (raw) => parseEnum(raw, CHROME_SOURCES, "[lambda deploy] --chrome-source", "sparticuz");
+var VIDEO_ARCHS = ["x86_64", "arm64"];
+var parseVideoArch = (raw) => parseEnum(raw, VIDEO_ARCHS, "[lambda deploy] --video-arch", void 0);
+function parseOutputResolution(raw) {
+  return parseOutputResolutionFlag(raw, {
+    surfaceLabel: "[lambda render]",
+    // The Lambda `--output-resolution` help text advertises the full alias
+    // list (tier-only + orientation-suffixed) — keep the error message
+    // faithful to that surface's docs.
+    aliasHint: "1080p, 4k, uhd, hd, 1080p-portrait, portrait-1080p, 4k-portrait, 1080p-square, square-1080p, 4k-square"
+  });
+}
+export {
+  lambda_default as default,
+  examples
+};

package/vendor/framey/dist/layout-YET6XNXA.js

@@ -0,0 +1,95 @@
+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 {
+  createInspectCommand,
+  examples,
+  layout_default,
+  loadBrowserScript,
+  parseAt
+} from "./chunk-FUFP7A7S.js";
+import "./chunk-O4YRB27L.js";
+import "./chunk-O7BGSQ5F.js";
+import "./chunk-C5BO7PMT.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-6DDPOHMK.js";
+import "./chunk-XUHOIDKG.js";
+import "./chunk-THJALHFJ.js";
+import "./chunk-IUONB55J.js";
+import "./chunk-6JR2XUEE.js";
+import "./chunk-MI5FTLYK.js";
+import "./chunk-YPRBGITP.js";
+import "./chunk-7JQFJ6JJ.js";
+import "./chunk-SZNTYTIV.js";
+import "./chunk-YOR4CTCE.js";
+import "./chunk-KXTKKBOC.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-LEKZNRKI.js";
+import "./chunk-442JNXRM.js";
+import "./chunk-4BNN5FGX.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-WKBM7NDG.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-FLREUEHW.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-KLIKCX6Q.js";
+import "./chunk-EVMY7IPL.js";
+import "./chunk-7FMUTGOH.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-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.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";
+export {
+  createInspectCommand,
+  layout_default as default,
+  examples,
+  loadBrowserScript,
+  parseAt
+};