@higgsfield/video-editor-mcp 1.0.7 → 1.1.1-dev.0

package/node_modules/@higgsfield/higgsedit/dist/{chunk-27NBQ5FA.mjs → chunk-NUXTKQNM.mjs}

@@ -4,20 +4,22 @@ import { fileURLToPath as __higgseditPath } from "node:url";
 const require = __higgseditRequire(import.meta.url);
 const __filename = __higgseditPath(import.meta.url);
 const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
-import {
-  flag
-} from "./chunk-MCVD2ZQV.mjs";
 import {
   GoogleFontsUnavailable,
   cachedVariants,
   catalogueError,
   googleCatalogue,
+  googleFontsDir,
   googleFontsOff,
   stylesheetUrl
 } from "./chunk-2VKQHJMM.mjs";
-import "./chunk-75WO2NOF.mjs";
+import {
+  fontFileFacts
+} from "./chunk-BV5COOQZ.mjs";
 
 // src/fonts/list.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 var FONT_CATEGORIES = ["sans-serif", "serif", "display", "handwriting", "monospace"];
 var FONT_LIMIT = 50;
 async function listFonts(query, options = {}) {
@@ -28,12 +30,33 @@ async function listFonts(query, options = {}) {
   }
   const needle = query.family?.trim().toLowerCase();
   const matches = cat.families.filter((f) => (!needle || f.family.toLowerCase().includes(needle)) && (!query.category || f.category === query.category)).map((f) => ({ ...f, cached: cachedVariants(f.family, options), stylesheet: stylesheetUrl(f) })).filter((f) => !query.cached || f.cached.length > 0).toSorted((a, b) => Number(b.family.toLowerCase() === needle) - Number(a.family.toLowerCase() === needle) || a.popularity - b.popularity || a.family.localeCompare(b.family));
+  const offset = query.offset ?? 0;
   return {
-    families: matches.slice(0, query.limit ?? FONT_LIMIT),
+    families: matches.slice(offset, offset + (query.limit ?? FONT_LIMIT)),
     total: matches.length,
     catalogue: { fetchedAt: new Date(cat.fetchedAt).toISOString(), stale: cat.stale }
   };
 }
+async function cachedFonts(query, options = {}) {
+  const root = googleFontsDir(options);
+  const dirs = existsSync(root) ? readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()) : [];
+  const found = await Promise.all(
+    dirs.map(async (d) => {
+      const files = readdirSync(join(root, d.name)).filter((f) => !f.endsWith(".tmp"));
+      if (!files.length) return null;
+      const bytes = readFileSync(join(root, d.name, files[0]));
+      const facts = await fontFileFacts(files[0], bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)).catch(() => null);
+      if (!facts) return null;
+      const cached = cachedVariants(d.name, options);
+      const weights = (italic) => cached.filter((v) => v.endsWith("i") === italic).map((v) => Number.parseInt(v, 10));
+      return { family: facts.family, category: "", popularity: 0, weights: weights(false), italics: weights(true), cached };
+    })
+  );
+  const needle = query.family?.trim().toLowerCase();
+  const matches = found.filter((f) => f !== null).filter((f) => (!needle || f.family.toLowerCase().includes(needle)) && !query.category).toSorted((a, b) => a.family.localeCompare(b.family));
+  const offset = query.offset ?? 0;
+  return { families: matches.slice(offset, offset + (query.limit ?? FONT_LIMIT)), total: matches.length };
+}
 var variants = (f) => `${f.weights.join(",")}${f.italics.length ? ` +italic ${f.italics.join(",")}` : ""}`.trim();
 function fontListText(list) {
   const width = Math.max(0, ...list.families.map((f) => f.family.length));
@@ -42,21 +65,10 @@ function fontListText(list) {
   return lines.join("\n");
 }
 
-// src/fonts/cli.ts
-async function runFonts(args, print) {
-  const category = flag(args, "category");
-  if (category && !FONT_CATEGORIES.includes(category)) throw new Error(`unknown --category ${category}; use ${FONT_CATEGORIES.join(", ")}`);
-  const limit = flag(args, "limit");
-  const query = {
-    ...args.positional[0] ? { family: args.positional[0] } : {},
-    ...category ? { category } : {},
-    ...args.flags.cached === true ? { cached: true } : {},
-    ...limit ? { limit: Number(limit) } : {}
-  };
-  const list = await listFonts(query);
-  print(list, () => fontListText(list));
-  return 0;
-}
 export {
-  runFonts
+  FONT_CATEGORIES,
+  FONT_LIMIT,
+  listFonts,
+  cachedFonts,
+  fontListText
 };

package/node_modules/@higgsfield/higgsedit/dist/chunk-OCIZ36XD.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  SELECT_USAGE,
+  SelectError,
+  grabFrame,
+  parsePrompt,
+  pickObject,
+  requireSelectBackend,
+  runSelect,
+  select,
+  selectBackend,
+  selectFrame,
+  selectStatus,
+  track
+} from "./chunk-WENFTPXQ.mjs";
+import "./chunk-QJTILFBS.mjs";
+import "./chunk-PAHMD6SU.mjs";
+import "./chunk-BV5COOQZ.mjs";
+import "./chunk-F7YUKEI5.mjs";
+import "./chunk-MCVD2ZQV.mjs";
+import "./chunk-75WO2NOF.mjs";
+export {
+  SELECT_USAGE,
+  SelectError,
+  grabFrame,
+  parsePrompt,
+  pickObject,
+  requireSelectBackend,
+  runSelect,
+  select,
+  selectBackend,
+  selectFrame,
+  selectStatus,
+  track
+};

package/node_modules/@higgsfield/higgsedit/dist/{chunk-MK6PL7N4.mjs → chunk-OF6RMSM2.mjs}

@@ -10,7 +10,7 @@ import {
   isComponentTag,
   isIntrinsicTag,
   tagName
-} from "./chunk-VI6IV6JP.mjs";
+} from "./chunk-MV2JTTBQ.mjs";
 import {
   CompileError,
   EXTERNALS,
@@ -18,17 +18,29 @@ import {
   compileFile,
   evaluateProject,
   findEntry,
-  fontFiles,
-  inside,
   mountComponent,
   packageModules,
-  readSources,
   resolveSyncs
-} from "./chunk-SIMO6I3D.mjs";
+} from "./chunk-UDL5AHKO.mjs";
+import {
+  fontFiles,
+  inside,
+  readSources
+} from "./chunk-LTKMGZ6T.mjs";
 import {
   CHROME_ARGS,
   installedChrome
-} from "./chunk-6BETMESC.mjs";
+} from "./chunk-P2BGHTRR.mjs";
+import {
+  probe,
+  probeAudio
+} from "./chunk-PAHMD6SU.mjs";
+import {
+  GoogleFontsUnavailable,
+  googleFace,
+  googleFontsOff,
+  variantName
+} from "./chunk-2VKQHJMM.mjs";
 import {
   Captions,
   Extra,
@@ -63,20 +75,10 @@ import {
   uniformDecls,
   usedFonts,
   wgslMessage
-} from "./chunk-WZR5PZM7.mjs";
+} from "./chunk-BV5COOQZ.mjs";
 import {
   TRANSITION_TYPES
 } from "./chunk-F7YUKEI5.mjs";
-import {
-  probe,
-  probeAudio
-} from "./chunk-EKFC4S4M.mjs";
-import {
-  GoogleFontsUnavailable,
-  googleFace,
-  googleFontsOff,
-  variantName
-} from "./chunk-2VKQHJMM.mjs";
 
 // src/check.ts
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";

package/node_modules/@higgsfield/higgsedit/dist/{chunk-6BETMESC.mjs → chunk-P2BGHTRR.mjs}

@@ -22,7 +22,7 @@ function hostPlatform() {
 }
 function installedChrome(options = {}) {
   const env = options.env ?? process.env;
-  const own = env.HIGGSEDIT_NEXT_CHROME ?? env.HIGGSEDIT_CHROME;
+  const own = env.HIGGSEDIT_NEXT_CHROME;
   if (own) return existsSync(own) ? own : void 0;
   const platform = options.platform ?? hostPlatform();
   const binary = join(options.home ?? env.HIGGSEDIT_HOME ?? join(homedir(), ".higgsedit-next"), "chrome", CHROME_VERSION, `chrome-headless-shell-${platform}`, "chrome-headless-shell");
@@ -30,7 +30,7 @@ function installedChrome(options = {}) {
 }
 async function ensureChrome(options = {}) {
   const env = options.env ?? process.env;
-  const own = env.HIGGSEDIT_NEXT_CHROME ?? env.HIGGSEDIT_CHROME;
+  const own = env.HIGGSEDIT_NEXT_CHROME;
   if (own) {
     if (!existsSync(own)) throw new Error(`headless Chrome not found at ${own} (from HIGGSEDIT_NEXT_CHROME)`);
     return own;

package/node_modules/@higgsfield/higgsedit/dist/{chunk-EKFC4S4M.mjs → chunk-PAHMD6SU.mjs}

@@ -57,9 +57,14 @@ function probe(file) {
       const [fn, fd] = String(video.avg_frame_rate || video.r_frame_rate).split("/").map(Number);
       const fps = fd ? fn / fd : fn;
       const startTime = Number(video.start_time ?? info.format.start_time ?? 0) || 0;
+      const [sarW, sarH] = String(video.sample_aspect_ratio ?? "1:1").split(":").map(Number);
+      const wide = Math.round(Number(video.width) * (sarW > 0 && sarH > 0 ? sarW / sarH : 1));
+      const sides = video.side_data_list ?? [];
+      const turned = Math.abs(sides.find((s) => s.rotation !== void 0)?.rotation ?? 0) % 180 === 90;
       return {
         width: Number(video.width),
         height: Number(video.height),
+        display: turned ? [Number(video.height), wide] : [wide, Number(video.height)],
         fps,
         duration: timestamps.length ? timestamps[timestamps.length - 1] - Math.max(0, timestamps[0]) + 1 / fps : Number(info.format.duration),
         codec: String(video.codec_name),

package/node_modules/@higgsfield/higgsedit/dist/{chunk-QVLAEV3U.mjs → chunk-PFQYUJQL.mjs}

@@ -6,7 +6,7 @@ const __filename = __higgseditPath(import.meta.url);
 const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
 import {
   CLI_MANIFEST
-} from "./chunk-FZ5U36SQ.mjs";
+} from "./chunk-2WKNH7OL.mjs";
 import "./chunk-75WO2NOF.mjs";
 
 // src/init.ts
@@ -47,8 +47,7 @@ function scaffold(dir, options = {}) {
         private: true,
         type: "module",
         scripts: { dev: "higgsedit dev .", check: "higgsedit check .", typecheck: "tsc", render: "higgsedit render . -o renders/out.mp4" },
-        dependencies: { "@higgsfield-ai/video-editor-next": CLI_MANIFEST.version },
-        devDependencies: { "@higgsfield-ai/higgsedit": CLI_MANIFEST.version, typescript }
+        devDependencies: { [CLI_MANIFEST.name]: CLI_MANIFEST.version, typescript }
       })
     },
     {
@@ -60,7 +59,7 @@ function scaffold(dir, options = {}) {
           moduleResolution: "bundler",
           lib: ["ES2022", "DOM", "DOM.Iterable"],
           jsx: "preserve",
-          jsxImportSource: "@higgsfield-ai/video-editor-next/jsx",
+          jsxImportSource: `${CLI_MANIFEST.name}/jsx`,
           strict: true,
           noEmit: true,
           isolatedModules: true,

package/node_modules/@higgsfield/higgsedit/dist/chunk-QJTILFBS.mjs

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  ffmpeg,
+  matrixOf,
+  probe,
+  requireTool
+} from "./chunk-PAHMD6SU.mjs";
+import {
+  frameIndexAt
+} from "./chunk-BV5COOQZ.mjs";
+
+// src/media/image.ts
+import { crc32, deflateSync } from "node:zlib";
+var GLYPHS = {
+  "0": [".###.", "#...#", "#..##", "#.#.#", "##..#", "#...#", ".###."],
+  "1": ["..#..", ".##..", "..#..", "..#..", "..#..", "..#..", ".###."],
+  "2": [".###.", "#...#", "....#", "...#.", "..#..", ".#...", "#####"],
+  "3": ["####.", "....#", "....#", ".###.", "....#", "....#", "####."],
+  "4": ["...#.", "..##.", ".#.#.", "#..#.", "#####", "...#.", "...#."],
+  "5": ["#####", "#....", "####.", "....#", "....#", "#...#", ".###."],
+  "6": ["..##.", ".#...", "#....", "####.", "#...#", "#...#", ".###."],
+  "7": ["#####", "....#", "...#.", "..#..", ".#...", ".#...", ".#..."],
+  "8": [".###.", "#...#", "#...#", ".###.", "#...#", "#...#", ".###."],
+  "9": [".###.", "#...#", "#...#", ".####", "....#", "...#.", ".##.."],
+  ":": [".....", "..#..", "..#..", ".....", "..#..", "..#..", "....."],
+  "-": [".....", ".....", ".....", ".###.", ".....", ".....", "....."],
+  ".": [".....", ".....", ".....", ".....", ".....", ".##..", ".##.."],
+  h: ["#....", "#....", "#.##.", "##..#", "#...#", "#...#", "#...#"],
+  m: [".....", ".....", "##.#.", "#.#.#", "#.#.#", "#.#.#", "#.#.#"],
+  s: [".....", ".....", ".####", "#....", ".###.", "....#", "####."],
+  f: ["..##.", ".#..#", ".#...", "###..", ".#...", ".#...", ".#..."],
+  " ": [".....", ".....", ".....", ".....", ".....", ".....", "....."]
+};
+var GLYPH_W = 5;
+var GLYPH_H = 7;
+var Bitmap = class {
+  constructor(width, height, background = [0, 0, 0, 255]) {
+    this.width = width;
+    this.height = height;
+    this.data = new Uint8Array(width * height * 4);
+    this.fill(0, 0, width, height, background);
+  }
+  width;
+  height;
+  data;
+  /** Fills a rectangle, alpha-blending over what is there. */
+  fill(x, y, w, h, [r, g, b, a]) {
+    const x0 = Math.max(0, Math.round(x));
+    const y0 = Math.max(0, Math.round(y));
+    const x1 = Math.min(this.width, Math.round(x + w));
+    const y1 = Math.min(this.height, Math.round(y + h));
+    const k = a / 255;
+    for (let yy = y0; yy < y1; yy++) {
+      for (let xx = x0; xx < x1; xx++) {
+        const i = (yy * this.width + xx) * 4;
+        const d = this.data;
+        d[i] = Math.round(r * k + d[i] * (1 - k));
+        d[i + 1] = Math.round(g * k + d[i + 1] * (1 - k));
+        d[i + 2] = Math.round(b * k + d[i + 2] * (1 - k));
+        d[i + 3] = 255;
+      }
+    }
+  }
+  /** Copies an opaque RGBA8 image of `w`x`h` to (`x`, `y`). */
+  blit(rgba, w, h, x, y) {
+    for (let row = 0; row < h; row++) {
+      const yy = y + row;
+      if (yy < 0 || yy >= this.height) continue;
+      const from = Math.max(0, -x);
+      const to = Math.min(w, this.width - x);
+      if (to <= from) continue;
+      this.data.set(rgba.subarray((row * w + from) * 4, (row * w + to) * 4), (yy * this.width + x + from) * 4);
+    }
+  }
+  /** Draws `text` with its top-left at (`x`, `y`), each font pixel `px` screen pixels square. */
+  text(text, x, y, px, color) {
+    let cx = x;
+    for (const ch of text) {
+      const glyph = GLYPHS[ch] ?? GLYPHS[" "];
+      for (let gy = 0; gy < GLYPH_H; gy++) for (let gx = 0; gx < GLYPH_W; gx++) if (glyph[gy][gx] === "#") this.fill(cx + gx * px, y + gy * px, px, px, color);
+      cx += (GLYPH_W + 1) * px;
+    }
+  }
+  png() {
+    return encodePng(this.data, this.width, this.height);
+  }
+};
+var textWidth = (text, px) => Math.max(0, [...text].length * (GLYPH_W + 1) * px - px);
+var textHeight = (px) => GLYPH_H * px;
+var chunk = (type, body) => {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(body.length, 0);
+  head.write(type, 4, "latin1");
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), body])) >>> 0, 0);
+  return Buffer.concat([head, body, crc]);
+};
+var FILTER_TYPES = [0, 1, 2, 4];
+var paeth = (a, b, c) => {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+};
+function encodePng(rgba, width, height) {
+  const stride = width * 4;
+  const raw = Buffer.alloc((stride + 1) * height);
+  const candidates = Array.from({ length: 4 }, () => new Uint8Array(stride));
+  for (let y = 0; y < height; y++) {
+    const row = rgba.subarray(y * stride, (y + 1) * stride);
+    const up = y > 0 ? rgba.subarray((y - 1) * stride, y * stride) : void 0;
+    const [none, sub, upF, pa] = candidates;
+    for (let i = 0; i < stride; i++) {
+      const x = row[i];
+      const a = i >= 4 ? row[i - 4] : 0;
+      const b = up ? up[i] : 0;
+      const c = up && i >= 4 ? up[i - 4] : 0;
+      none[i] = x;
+      sub[i] = x - a & 255;
+      upF[i] = x - b & 255;
+      pa[i] = x - paeth(a, b, c) & 255;
+    }
+    let best = 0;
+    let bestCost = Infinity;
+    candidates.forEach((cand, k) => {
+      let cost = 0;
+      for (let i = 0; i < stride; i++) cost += cand[i] < 128 ? cand[i] : 256 - cand[i];
+      if (cost < bestCost) {
+        bestCost = cost;
+        best = k;
+      }
+    });
+    raw[y * (stride + 1)] = FILTER_TYPES[best];
+    raw.set(candidates[best], y * (stride + 1) + 1);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk("IHDR", ihdr), chunk("IDAT", deflateSync(raw, { level: 6 })), chunk("IEND", new Uint8Array(0))]);
+}
+
+// src/media/source.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+function resolveMediaPath(path, base) {
+  if (path === "~" || path.startsWith("~/")) return join(homedir(), path.slice(1));
+  if (isAbsolute(path)) return resolve(path);
+  if (!base) throw new Error(`"${path}" is a relative path: open a project first or pass an absolute path`);
+  return resolve(base, path);
+}
+function assertFile(file) {
+  if (!existsSync(file)) throw new Error(`No such file: ${file}`);
+  const st = statSync(file);
+  if (!st.isFile()) throw new Error(`Not a file: ${file}`);
+  return st.size;
+}
+var num = (v) => {
+  if (v === void 0 || v === null || v === "" || v === "N/A") return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+};
+var str = (v) => typeof v === "string" && v !== "" && v !== "unknown" ? v : void 0;
+var rate = (v) => {
+  const [n, d] = String(v ?? "").split("/").map(Number);
+  if (!n || !d) return void 0;
+  return Math.round(n / d * 1e3) / 1e3;
+};
+var defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+var IMAGE_FORMATS = /^(image2|.*_pipe|gif|webp|png|apng)$/;
+async function probeMedia(file) {
+  const size = assertFile(file);
+  const ffprobe = requireTool("ffprobe");
+  let info;
+  try {
+    const { stdout } = await run(ffprobe, ["-v", "error", "-show_format", "-show_streams", "-of", "json", file], { maxBuffer: 1 << 24 });
+    info = JSON.parse(stdout);
+  } catch {
+    return { path: file, name: basename(file), type: "other", size, format: null, tracks: [] };
+  }
+  const format = info.format ?? {};
+  const tracks = (info.streams ?? []).map((s) => {
+    const tags = s.tags ?? {};
+    const side = s.side_data_list ?? [];
+    const video = s.codec_type === "video";
+    const audio = s.codec_type === "audio";
+    return defined({
+      id: Number(s.index),
+      type: String(s.codec_type ?? "unknown"),
+      codec: str(s.codec_name) ?? null,
+      codecLongName: str(s.codec_long_name),
+      profile: str(s.profile),
+      language: tags.language ?? "und",
+      firstTimestamp: num(s.start_time) ?? 0,
+      duration: num(s.duration) ?? num(format.duration) ?? 0,
+      bitRate: num(s.bit_rate),
+      frames: num(s.nb_frames),
+      ...video ? {
+        width: num(s.width),
+        height: num(s.height),
+        fps: rate(s.avg_frame_rate) ?? rate(s.r_frame_rate),
+        pixFmt: str(s.pix_fmt),
+        colorSpace: str(s.color_space),
+        colorRange: str(s.color_range),
+        colorTransfer: str(s.color_transfer),
+        colorPrimaries: str(s.color_primaries),
+        rotation: num(side.find((d) => d.rotation !== void 0)?.rotation)
+      } : {},
+      ...audio ? { sampleRate: num(s.sample_rate), channels: num(s.channels), channelLayout: str(s.channel_layout) } : {}
+    });
+  });
+  const formatName = str(format.format_name) ?? null;
+  const visual = tracks.find((t) => t.type === "video");
+  const still = formatName !== null && IMAGE_FORMATS.test(formatName);
+  const type = visual ? still ? "image" : "video" : tracks.some((t) => t.type === "audio") ? "audio" : "other";
+  return defined({
+    path: file,
+    name: basename(file),
+    type,
+    size,
+    format: formatName,
+    formatLongName: str(format.format_long_name),
+    duration: still ? void 0 : num(format.duration),
+    bitRate: num(format.bit_rate),
+    width: visual?.width,
+    height: visual?.height,
+    tags: format.tags && Object.keys(format.tags).length ? format.tags : void 0,
+    tracks
+  });
+}
+async function videoSource(file) {
+  assertFile(file);
+  const p = await probe(file).catch((error) => {
+    if (error instanceof Error && /no video stream/.test(error.message)) throw new Error(`${file} has no video track`);
+    throw error;
+  });
+  if (!p.timestamps.length) throw new Error(`${file} has no video frames`);
+  return {
+    file,
+    width: p.width,
+    height: p.height,
+    fps: p.fps,
+    duration: p.duration,
+    origin: Math.max(0, p.timestamps[0]),
+    timestamps: p.timestamps,
+    matrix: matrixOf(p),
+    range: p.colorRange === "pc" ? "full" : "limited"
+  };
+}
+var frameAt = (src, t) => frameIndexAt(src.timestamps, src.origin + t, src.fps);
+var frameTime = (src, index) => src.timestamps[index] - src.origin;
+var gridFrame = (src, index) => Math.round(frameTime(src, index) * src.fps);
+var collect = (proc, what) => new Promise((done, failed) => {
+  const out = [];
+  const err = [];
+  proc.stdout.on("data", (b) => out.push(b));
+  proc.stderr.on("data", (b) => err.push(b));
+  proc.on("error", failed);
+  proc.on("close", (code) => code === 0 ? done(Buffer.concat(out)) : failed(new Error(`ffmpeg failed to decode ${what}: ${Buffer.concat(err).toString().trim() || `exit ${code}`}`)));
+});
+async function decodeFrame(src, index, width, height) {
+  const pts = src.timestamps[index];
+  const half = 0.25 / src.fps;
+  const seek = Math.max(0, pts - src.origin - 2);
+  const scale = `scale=w=${width}:h=${height}:flags=area:in_color_matrix=${src.matrix}:in_range=${src.range}:out_range=full,format=rgba`;
+  const proc = ffmpeg(["-copyts", "-ss", seek.toFixed(6), "-noaccurate_seek", "-i", src.file, "-map", "0:v:0", "-vf", `select=gte(t\\,${(pts - half).toFixed(6)}),${scale}`, "-frames:v", "1", "-f", "rawvideo", "-"]);
+  const bytes = await collect(proc, `frame ${index} of ${src.file}`);
+  if (bytes.length !== width * height * 4) throw new Error(`could not decode frame ${index} of ${src.file}`);
+  return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.length);
+}
+async function decodeAudio(file, start, end, rate2) {
+  const proc = ffmpeg(["-ss", start.toFixed(6), "-t", (end - start).toFixed(6), "-i", file, "-map", "0:a:0", "-ac", "1", "-ar", String(rate2), "-f", "f32le", "-"]);
+  const bytes = await collect(proc, `audio of ${file}`);
+  const copy = new Uint8Array(bytes.length - bytes.length % 4);
+  copy.set(bytes.subarray(0, copy.length));
+  return new Float32Array(copy.buffer);
+}
+async function pool(items, limit, job) {
+  const out = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await job(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+function outputDir(dir, prefix) {
+  if (!dir) return mkdtempSync(join(tmpdir(), `${prefix}-`));
+  const abs = resolve(dir);
+  mkdirSync(abs, { recursive: true });
+  return abs;
+}
+function writeOutput(data, output, prefix, ext = "png") {
+  const fresh = `${prefix}-${randomUUID()}.${ext}`;
+  let file;
+  if (!output) file = join(tmpdir(), fresh);
+  else if (existsSync(output) && statSync(output).isDirectory()) file = join(resolve(output), fresh);
+  else file = resolve(output);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, data);
+  return file;
+}
+
+export {
+  Bitmap,
+  textWidth,
+  textHeight,
+  encodePng,
+  resolveMediaPath,
+  probeMedia,
+  videoSource,
+  frameAt,
+  frameTime,
+  gridFrame,
+  decodeFrame,
+  decodeAudio,
+  pool,
+  outputDir,
+  writeOutput
+};

package/node_modules/@higgsfield/higgsedit/dist/chunk-QQ3GGKDN.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  check
+} from "./chunk-OF6RMSM2.mjs";
+import "./chunk-MV2JTTBQ.mjs";
+import "./chunk-UDL5AHKO.mjs";
+import "./chunk-LTKMGZ6T.mjs";
+import "./chunk-P2BGHTRR.mjs";
+import "./chunk-PAHMD6SU.mjs";
+import "./chunk-2VKQHJMM.mjs";
+import "./chunk-BV5COOQZ.mjs";
+import "./chunk-F7YUKEI5.mjs";
+import "./chunk-75WO2NOF.mjs";
+export {
+  check
+};

package/node_modules/@higgsfield/higgsedit/dist/chunk-TH7TK67K.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  assertProject,
+  fontFiles,
+  inside,
+  readSources,
+  rel,
+  sourceFiles
+} from "./chunk-LTKMGZ6T.mjs";
+import "./chunk-75WO2NOF.mjs";
+export {
+  assertProject,
+  fontFiles,
+  inside,
+  readSources,
+  rel,
+  sourceFiles
+};