@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/remove-background-W2YX2NVH.js

@@ -0,0 +1,253 @@
+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_QUALITY,
+  QUALITIES,
+  isQuality
+} from "./chunk-LHSR3M4M.js";
+import {
+  DEVICES,
+  isDevice
+} from "./chunk-2EAXUCCE.js";
+import {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import "./chunk-X5HWXQPU.js";
+import "./chunk-TVCRUG2S.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-AMKC3AXA.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.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-LCSMOLGX.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 "./chunk-XT5P4QMO.js";
+import "./chunk-6BEFEWFB.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/remove-background.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+var examples = [
+  [
+    "Remove background from a video, output transparent VP9 WebM (default)",
+    "hyperframes remove-background avatar.mp4 -o transparent.webm"
+  ],
+  [
+    "Output ProRes 4444 .mov for editing round-trip",
+    "hyperframes remove-background avatar.mp4 -o transparent.mov"
+  ],
+  [
+    "Remove background from a single image, output transparent PNG",
+    "hyperframes remove-background portrait.jpg -o cutout.png"
+  ],
+  [
+    "Separate the layers \u2014 emit both the cutout and an inverse-alpha background plate (subject region transparent)",
+    "hyperframes remove-background avatar.mp4 -o subject.webm --background-output plate.webm"
+  ],
+  [
+    "Force CPU (skip CoreML/CUDA)",
+    "hyperframes 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)",
+    "hyperframes remove-background avatar.mp4 -o transparent.webm --quality fast"
+  ],
+  [
+    "Visually-lossless WebM (master / re-encode source)",
+    "hyperframes remove-background avatar.mp4 -o transparent.webm --quality best"
+  ],
+  ["Show detected providers without rendering", "hyperframes 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 `hyperframes 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 inputPath = resolve(args.input);
+    const outputPath = resolve(args.output);
+    const backgroundOutputArg = args["background-output"];
+    const backgroundOutputPath = backgroundOutputArg ? resolve(backgroundOutputArg) : void 0;
+    const { render } = await import("./pipeline-TNGWUZQC.js");
+    const spin = args.json ? null : ft();
+    spin?.start("Preparing background-removal pipeline...");
+    try {
+      const result = await render({
+        inputPath,
+        outputPath,
+        backgroundOutputPath,
+        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, err);
+    }
+  }
+});
+async function showInfo(json) {
+  const { selectProviders, listAvailableProviders, DEFAULT_MODEL, MODEL_MEMORY_MB, modelPath } = await import("./manager-GFN75DM4.js");
+  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("hyperframes 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/hyperframes/dist/render-AO5VX3YI.js

@@ -0,0 +1,177 @@
+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-THXFSPLV.js";
+import {
+  requireStack,
+  stateFilePath
+} from "./chunk-H4YZZ2VQ.js";
+import {
+  reportVariableIssues,
+  resolveVariablesArg,
+  validateVariablesAgainstProject
+} from "./chunk-6CTIGJY7.js";
+import "./chunk-5Z63TBTX.js";
+import "./chunk-IHFUKJOR.js";
+import "./chunk-PFCFR3KZ.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.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("@hyperframes/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);
+  const siteHandle = args.siteId ? {
+    siteId: args.siteId,
+    bucketName: stack.bucketName,
+    projectS3Uri: `s3://${stack.bucketName}/sites/${args.siteId}/project.tar.gz`,
+    bytes: 0,
+    uploadedAt: "",
+    uploaded: false
+  } : void 0;
+  const { renderToLambda } = await loadSDK();
+  const handle = await renderToLambda({
+    projectDir: siteHandle ? void 0 : projectDir,
+    siteHandle,
+    bucketName: stack.bucketName,
+    stateMachineArn: stack.stateMachineArn,
+    region: stack.region,
+    config,
+    executionName: args.executionName,
+    outputKey: args.outputKey
+  });
+  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: hyperframes lambda progress ${handle.renderId}`));
+}
+async function waitForCompletion(executionArn, stack, intervalMs, json) {
+  const { getRenderProgress } = await loadSDK();
+  let lastRendered = -1;
+  while (true) {
+    const progress = await getRenderProgress({
+      executionArn,
+      region: stack.region,
+      defaultMemorySizeMb: stack.lambdaMemoryMb
+    });
+    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) {
+  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,
+    runtimeCap: "lambda",
+    variables
+  };
+  if (args.outputResolutionAspectAgnostic) {
+    config.outputResolutionAspectAgnostic = true;
+  }
+  return config;
+}
+export {
+  buildLambdaRenderConfig,
+  runRender
+};