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

package/node_modules/@higgsfield/higgsedit/dist/export-settings.mjs

@@ -1,75 +0,0 @@
-import { ffmpeg } from "./chunk-EKFC4S4M.mjs";
-import { parseTime } from "./chunk-F7YUKEI5.mjs";
-
-// This is the native renderer's contract; the iframe's encoders do not constrain it.
-const sampleRates = [44100, 48000, 96000];
-let capabilities;
-export function renderCapabilities() {
-  capabilities ??= new Promise((resolve, reject) => {
-    const child = ffmpeg(["-encoders"]);
-    let output = "";
-    child.stdout.on("data", (chunk) => output += chunk.toString());
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code !== 0) return reject(new Error("could not inspect native video encoders"));
-      const has = (name) => new RegExp(`^\\s*[A-Z.]{6}\\s+${name}\\s`, "m").test(output);
-      const videoCodecs = [...has("libx264") ? ["avc"] : [], ...has("libx265") ? ["hevc"] : []];
-      resolve({ containers: videoCodecs.length ? ["mp4"] : [], videoCodecs, audioCodecs: has("aac") ? ["aac"] : [], sampleRates, audioOnly: false });
-    });
-  }).catch((error) => { capabilities = undefined; throw error; });
-  return capabilities;
-}
-
-const object = (value, label) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-  return value;
-};
-const number = (value, label, min, max, integer = false) => {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value)) throw new Error(`${label} must be ${integer ? "an integer" : "a number"} between ${min} and ${max}`);
-  return value;
-};
-const member = (value, allowed, label) => {
-  if (!allowed.includes(value)) throw new Error(`unsupported ${label}: ${String(value)}`);
-  return value;
-};
-export function validateRenderRequest(input, supported) {
-  const body = object(input, "render request");
-  const out = {};
-  if (body.fileName !== undefined) {
-    if (typeof body.fileName !== "string" || !body.fileName.trim() || body.fileName.length > 180 || /[\x00-\x1f]/.test(body.fileName)) throw new Error("fileName must be a nonempty filename of at most 180 characters");
-    out.fileName = body.fileName;
-  }
-  if (body.sceneId !== undefined) {
-    if (typeof body.sceneId !== "string" || !body.sceneId || body.sceneId.length > 1024) throw new Error("sceneId must be a nonempty scene identifier");
-    out.sceneId = body.sceneId;
-  }
-  for (const key of ["from", "to"]) {
-    if (body[key] === undefined) continue;
-    const time = parseTime(body[key], 30);
-    if (time === undefined || !Number.isFinite(time) || time < 0 || typeof body[key] === "string" && body[key].length > 64) throw new Error(`${key} must be a nonnegative time`);
-    out[key] = body[key];
-  }
-  out.depth = body.depth === undefined ? 8 : member(body.depth, [8, 10], "bit depth");
-  out.allowFontFallback = body.allowFontFallback === true;
-  if (body.spec === undefined) return out;
-  const spec = object(body.spec, "spec");
-  const video = object(spec.video, "spec.video (audio-only export is unavailable)");
-  const width = number(video.width, "video width", 2, 8192, true);
-  const height = number(video.height, "video height", 2, 8192, true);
-  if (width % 2 || height % 2 || width * height > 35389440) throw new Error("video dimensions must be even and no larger than 8K");
-  const normalized = {
-    container: member(spec.container, supported.containers, "container"),
-    video: { width, height, fps: number(video.fps, "video fps", 1, 120), codec: member(video.codec, supported.videoCodecs, "video codec") },
-    audio: null
-  };
-  if (video.bitrate !== undefined) normalized.video.bitrate = number(video.bitrate, "video bitrate", 1000, 1000000000, true);
-  if (spec.audio !== null) {
-    const audio = object(spec.audio, "spec.audio");
-    normalized.audio = { codec: member(audio.codec, supported.audioCodecs, "audio codec"), sampleRate: member(audio.sampleRate, supported.sampleRates, "audio sample rate"), channels: member(audio.channels, [1, 2], "audio channels") };
-    if (audio.bitrate !== undefined) normalized.audio.bitrate = number(audio.bitrate, "audio bitrate", 16000, 1024000, true);
-  }
-  // The explicit codec selects its native encoder. Legacy --depth still applies without a spec.
-  out.depth = 8;
-  out.spec = normalized;
-  return out;
-}

package/node_modules/@higgsfield/higgsedit/dist/history.mjs

@@ -1,295 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-const MAX_BYTES = 16 * 1024 * 1024;
-const MAX_ENTRIES = 100;
-const STALE = "edit history changed in another editor; reopen the project before editing or undoing";
-const message = (error) => error instanceof Error ? error.message : String(error);
-const missing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
-const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const safePath = (path) => !/[\\\0]/.test(path) && path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part !== ".higgsedit-cache") && !/^[A-Za-z]:/.test(path);
-const identity = (stat) => `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-function encode(undo, redo, revision, text = (entry) => JSON.stringify(entryValue(entry))) {
-  return `{"version":1,"revision":${JSON.stringify(revision)},"undo":[${undo.map(text).join(",")}],"redo":[${redo.map(text).join(",")}]}`;
-}
-const entryValue = ({ name, files }) => ({ name, files: [...files].map(([path, texts]) => ({ path, ...texts })) });
-function decode(text) {
-  let value;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    return;
-  }
-  if (!record(value) || value.version !== 1 || typeof value.revision !== "string" || !Array.isArray(value.undo) || !Array.isArray(value.redo) || value.undo.length + value.redo.length > MAX_ENTRIES) return;
-  const entries = (stack) => {
-    const result = [];
-    for (const entry of stack) {
-      if (!record(entry) || typeof entry.name !== "string" || !Array.isArray(entry.files) || !entry.files.length) return;
-      const files = /* @__PURE__ */ new Map();
-      for (const file of entry.files) {
-        if (!record(file) || typeof file.path !== "string" || !safePath(file.path) || typeof file.before !== "string" || typeof file.after !== "string" || files.has(file.path)) return;
-        files.set(file.path, { before: file.before, after: file.after });
-      }
-      result.push({ name: entry.name, files });
-    }
-    return result;
-  };
-  const undo = entries(value.undo), redo = entries(value.redo);
-  return undo && redo ? { undo, redo } : void 0;
-}
-class EditHistory {
-  constructor(dir, onWrite, limits = {}) {
-    this.dir = dir;
-    this.onWrite = onWrite;
-    this.maxBytes = Math.min(MAX_BYTES, limits.maxBytes ?? MAX_BYTES);
-    this.maxEntries = Math.min(MAX_ENTRIES, limits.maxEntries ?? MAX_ENTRIES);
-    if (!Number.isSafeInteger(this.maxBytes) || this.maxBytes < 100 || !Number.isSafeInteger(this.maxEntries) || this.maxEntries < 1) throw new Error("invalid edit history limits");
-    try {
-      const saved = this.readJournal();
-      this.revision = saved.revision;
-      const parsed = saved.text === void 0 ? void 0 : decode(saved.text);
-      if (parsed) {
-        const bounded = this.bound(parsed.undo, parsed.redo);
-        this.undoStack = bounded.undo;
-        this.redoStack = bounded.redo;
-      }
-    } catch {
-    }
-  }
-  dir;
-  onWrite;
-  undoStack = [];
-  redoStack = [];
-  revision = "missing";
-  maxBytes;
-  maxEntries;
-  // Committed entries never change. Weak keys release evicted history and abandoned transactions.
-  encoded = /* @__PURE__ */ new WeakMap();
-  begin(name) {
-    if (typeof name !== "string") throw new Error("edit history name must be a string");
-    this.assertCurrent();
-    const entry = { name, files: /* @__PURE__ */ new Map() };
-    const previousWrites = /* @__PURE__ */ new Map();
-    const fileBytes = /* @__PURE__ */ new Map();
-    let entryBytes = Buffer.byteLength(encode([entry], [], randomUUID()));
-    let finished = false;
-    return {
-      onWrite: (path, text) => {
-        if (finished) throw new Error("edit history transaction already finished");
-        const prior = entry.files.get(path);
-        const current = this.readSource(path);
-        if (prior && current !== prior.after) throw new Error(`${path} changed outside the editor since ${entry.name}`);
-        const texts = { before: prior?.before ?? current, after: text };
-        const bytes = Buffer.byteLength(JSON.stringify({ path, ...texts }));
-        const nextBytes = entryBytes - (fileBytes.get(path) ?? 0) + bytes + (!prior && entry.files.size ? 1 : 0);
-        if (nextBytes > this.maxBytes) throw new Error(`edit history size limit exceeded (${this.maxBytes} bytes); split the edit or reduce the affected source files`);
-        entryBytes = nextBytes;
-        fileBytes.set(path, bytes);
-        previousWrites.set(path, current);
-        entry.files.set(path, texts);
-        this.encoded.delete(entry);
-        this.onWrite?.(path, text);
-      },
-      commit: () => {
-        if (finished) throw new Error("edit history transaction already finished");
-        if (entry.files.size) {
-          this.checkSources(entry, "after");
-          this.publish([...this.undoStack, entry], []);
-        }
-        finished = true;
-      },
-      rollback: () => {
-        if (finished) return;
-        this.restore(entry, "after", "before", previousWrites);
-        finished = true;
-      }
-    };
-  }
-  state() {
-    return {
-      canUndo: this.undoStack.length > 0,
-      canRedo: this.redoStack.length > 0,
-      undoName: this.undoStack.at(-1)?.name ?? null,
-      redoName: this.redoStack.at(-1)?.name ?? null
-    };
-  }
-  undo() {
-    return this.step(this.undoStack, this.redoStack, "after", "before");
-  }
-  redo() {
-    return this.step(this.redoStack, this.undoStack, "before", "after");
-  }
-  step(from, to, expect, write) {
-    const entry = from.at(-1);
-    if (!entry) return { ok: false, reason: `nothing to ${write === "before" ? "undo" : "redo"}` };
-    try {
-      this.assertCurrent();
-      this.checkSources(entry, expect);
-    } catch (error) {
-      return { ok: false, reason: message(error) };
-    }
-    try {
-      for (const [path, texts] of entry.files) this.write(path, texts[write]);
-      const remaining = from.slice(0, -1), moved = [...to, entry];
-      this.publish(write === "before" ? remaining : moved, write === "before" ? moved : remaining);
-    } catch (error) {
-      try {
-        this.restore(entry, write, expect);
-      } catch (rollbackError) {
-        return { ok: false, reason: `${message(error)}; rollback failed: ${message(rollbackError)}` };
-      }
-      return { ok: false, reason: message(error) };
-    }
-    return { ok: true, written: [...entry.files.keys()] };
-  }
-  checkSources(entry, expect) {
-    for (const [path, texts] of entry.files) {
-      if (this.readSource(path) !== texts[expect]) throw new Error(`${path} changed outside the editor since ${entry.name}`);
-    }
-  }
-  /** A failed write may still contain the original text. Never roll back someone else's version. */
-  restore(entry, expect, restore, previousWrites) {
-    const pending = [];
-    for (const [path, texts] of entry.files) {
-      const current = this.readSource(path);
-      if (current === texts[restore]) continue;
-      if (current !== texts[expect] && current !== previousWrites?.get(path)) throw new Error(`${path} changed outside the editor since ${entry.name}`);
-      pending.push([path, texts[restore]]);
-    }
-    for (const [path, text] of pending) this.write(path, text);
-  }
-  readSource(path) {
-    if (!safePath(path)) throw new Error("unsafe edit history source path");
-    let target = this.dir;
-    for (const part of path.split("/")) {
-      target = join(target, part);
-      try {
-        if (lstatSync(target).isSymbolicLink()) throw new Error(`${path} is a symlink; cannot restore edit history`);
-      } catch (error) {
-        if (missing(error)) throw new Error(`${path} no longer exists`, { cause: error });
-        throw error;
-      }
-    }
-    return readFileSync(target, "utf8");
-  }
-  write(path, text) {
-    const target = join(this.dir, path);
-    this.onWrite?.(path, text);
-    this.atomicWrite(target, text, lstatSync(target).mode & 511);
-  }
-  cacheDir() {
-    const cache = join(this.dir, ".higgsedit-cache");
-    try {
-      const stat = lstatSync(cache);
-      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("unsafe edit history cache directory");
-    } catch (error) {
-      if (!missing(error)) throw error;
-    }
-    return cache;
-  }
-  readJournal() {
-    const file = join(this.cacheDir(), "history.json");
-    let fd;
-    try {
-      if (!lstatSync(file).isFile()) throw new Error("edit history journal is not a regular file");
-      fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    } catch (error) {
-      if (missing(error)) return { revision: "missing" };
-      throw new Error(`cannot read edit history: ${message(error)}`, { cause: error });
-    }
-    try {
-      const stat = fstatSync(fd, { bigint: true });
-      if (!stat.isFile()) throw new Error("edit history journal is not a regular file");
-      const revision = identity(stat);
-      if (stat.size > BigInt(this.maxBytes)) return { revision };
-      const bytes = Buffer.alloc(Number(stat.size) + 1);
-      let length = 0, count = 0;
-      do {
-        count = readSync(fd, bytes, length, bytes.length - length, null);
-        length += count;
-      } while (count && length < bytes.length);
-      if (BigInt(length) !== stat.size || identity(fstatSync(fd, { bigint: true })) !== revision) throw new Error("edit history changed while reading");
-      const data = bytes.subarray(0, length);
-      return { revision, text: data.toString("utf8") };
-    } finally {
-      closeSync(fd);
-    }
-  }
-  assertCurrent() {
-    let revision;
-    try {
-      const stat = lstatSync(join(this.cacheDir(), "history.json"), { bigint: true });
-      if (!stat.isFile()) throw new Error("edit history journal is not a regular file");
-      revision = identity(stat);
-    } catch (error) {
-      if (!missing(error)) throw error;
-      revision = "missing";
-    }
-    if (revision !== this.revision) throw new Error(STALE);
-  }
-  serialized(entry) {
-    let saved = this.encoded.get(entry);
-    if (!saved) {
-      const text = JSON.stringify(entryValue(entry));
-      saved = { text, bytes: Buffer.byteLength(text) };
-      this.encoded.set(entry, saved);
-    }
-    return saved;
-  }
-  bound(undo, redo) {
-    const revision = randomUUID();
-    const sized = (stack) => stack.map((entry) => ({ entry, bytes: this.serialized(entry).bytes }));
-    const keepUndo = sized(undo), keepRedo = sized(redo);
-    let bytes = Buffer.byteLength(encode([], [], revision)) + [...keepUndo, ...keepRedo].reduce((sum, entry) => sum + entry.bytes, 0);
-    const separators = () => Math.max(0, keepUndo.length - 1) + Math.max(0, keepRedo.length - 1);
-    while (keepUndo.length + keepRedo.length > this.maxEntries || bytes + separators() > this.maxBytes) {
-      const removed = keepUndo.length > 1 || !keepRedo.length ? keepUndo.shift() : keepRedo.shift();
-      if (!removed) throw new Error("edit history size limit exceeded");
-      bytes -= removed.bytes;
-    }
-    undo = keepUndo.map(({ entry }) => entry);
-    redo = keepRedo.map(({ entry }) => entry);
-    return { undo, redo, text: encode(undo, redo, revision, (entry) => this.serialized(entry).text) };
-  }
-  publish(undo, redo) {
-    const next = this.bound(undo, redo);
-    this.assertCurrent();
-    const cache = this.cacheDir();
-    mkdirSync(cache, { recursive: true, mode: 448 });
-    const target = join(cache, "history.json");
-    try {
-      this.revision = this.atomicWrite(target, next.text, 384);
-    } catch (error) {
-      throw new Error(`cannot save edit history: ${message(error)}`, { cause: error });
-    }
-    this.undoStack = next.undo;
-    this.redoStack = next.redo;
-  }
-  atomicWrite(target, text, mode) {
-    const tmp = `${target}.higgsedit-${process.pid}-${randomUUID()}.tmp`;
-    let published = false;
-    let fd;
-    try {
-      fd = openSync(tmp, "wx", mode);
-      writeFileSync(fd, text);
-      fsyncSync(fd);
-      renameSync(tmp, target);
-      published = true;
-      return identity(fstatSync(fd, { bigint: true }));
-    } finally {
-      try {
-        if (fd !== void 0) closeSync(fd);
-      } finally {
-        if (!published) {
-          try {
-            unlinkSync(tmp);
-          } catch {
-          }
-        }
-      }
-    }
-  }
-}
-export {
-  EditHistory
-};