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

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

@@ -4,13 +4,14 @@ 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 {
+  CLI_MANIFEST
+} from "./chunk-2WKNH7OL.mjs";
 import {
   flag,
   parseArgs
 } from "./chunk-MCVD2ZQV.mjs";
-import {
-  CLI_MANIFEST
-} from "./chunk-FZ5U36SQ.mjs";
+import "./chunk-75WO2NOF.mjs";
 
 // src/main.ts
 import { resolve } from "node:path";
@@ -35,14 +36,18 @@ var USAGE = `higgsedit <command> <dir> [options]
   verify <dir> [--count 12] [--depth 10]      determinism: forward vs shuffled capture hashes
   edit   <dir> <id> <op> <json>               write-back (set-prop, set-text, insert, remove, move, retime)
   edit   <dir> <name> set-const <value>       write an @inspect const (names: higgsedit outline)
-  dev    <dir> [--port 4173]                  editor with file watcher
+  dev    <dir> [--port 4173] [--presets <dir>]  editor with file watcher (presets: --presets, $HIGGSEDIT_PRESETS_DIR, ~/.higgsedit-next/presets)
   segment <media> --point x,y -o out.mask     track an object with SAM 2.1 into a .mask (mask={{ src }})
          [--point x,y \u2026] [--exclude x,y \u2026] [--box x0,y0,x1,y1] [--at t] [--start t] [--end t] [--model tiny|small|base-plus|large]
-  doctor                                      ffmpeg, Chrome, Node and recent plugin errors
+  select <media> --at t (--text "a, b" | --point x,y [--exclude x,y \u2026] [--box x0,y0,x1,y1])   objects on one frame with SAM 3.1 (HIGGSEDIT_SELECT_URL)
+         [--json] [--overlay sel.png] [--pick n --start t --end t -o out.mask]   -o tracks object --pick into a .mask (mask={{ src }})
+  doctor                                      ffmpeg, Chrome, Node, the select server, recent plugin errors
   version                                     print the version
   media  <probe|grab|filmstrip|waveform|transcribe> <path>  inspect footage (higgsedit media help)
   transcribe <media> -o out.json [--model m] [--language en]   word-timed transcript (local mlx_whisper) for <captions>
   fonts  [name] [--category c] [--cached] [--limit n]  Google Fonts families for <text fontFamily> (cached ones render offline)
+  presets [--json] [--presets <dir>]          installed motion presets (the editor's Presets panel adds them)
+  presets install <pack-dir> [--out <dir>] [--slots <file>]  build a presets dir from a pack (default: the one dev reads; replaces it)
 
   frame, sheet, render and verify fail when a project or Google font cannot be loaded, and check
   when a Google font cannot be downloaded; --allow-font-fallback draws in a fallback font instead, with a warning.
@@ -58,33 +63,41 @@ async function main(argv) {
     return 0;
   }
   if (command === "doctor") {
-    const { diagnose, diagnosisText } = await import("./chunk-CYH2EUQV.mjs");
-    const d = diagnose();
+    const { diagnose, diagnosisText } = await import("./chunk-DVN4LUXV.mjs");
+    const d = await diagnose();
     print(d, () => diagnosisText(d));
     return "path" in d.ffmpeg && "path" in d.ffprobe ? 0 : 1;
   }
   if (command === "media") {
-    const { runMedia } = await import("./chunk-MLJAIZGP.mjs");
+    const { runMedia } = await import("./chunk-BH2QF635.mjs");
     return runMedia(rest);
   }
   if (command === "segment") {
-    const { runSegment } = await import("./chunk-UVAZ6I6U.mjs");
+    const { runSegment } = await import("./chunk-KIWGVAPJ.mjs");
     return runSegment(args, print);
   }
+  if (command === "select") {
+    const { runSelect } = await import("./chunk-OCIZ36XD.mjs");
+    return runSelect(args, print);
+  }
   if (command === "transcribe") {
-    const { runTranscribe } = await import("./chunk-3AIM3THH.mjs");
+    const { runTranscribe } = await import("./chunk-VLM5EOWJ.mjs");
     return runTranscribe(args, print);
   }
   if (command === "fonts") {
-    const { runFonts } = await import("./chunk-27NBQ5FA.mjs");
+    const { runFonts } = await import("./chunk-LMQR3DHT.mjs");
     return runFonts(parseArgs(rest, /* @__PURE__ */ new Set(["json", "cached"])), print);
   }
+  if (command === "presets") {
+    const { runPresets } = await import("./chunk-IEPPEDEU.mjs");
+    return runPresets(args, print);
+  }
   if (!command || command === "help" || command === "--help" || !dirArg) {
     console.log(USAGE);
     return command ? 1 : 0;
   }
   if (command === "init") {
-    const { scaffold } = await import("./chunk-QVLAEV3U.mjs");
+    const { scaffold } = await import("./chunk-PFQYUJQL.mjs");
     const [w, h] = String(flag(args, "size") ?? "1080x1920").split("x").map(Number);
     const target = resolve(dirArg);
     const r = scaffold(target, { width: w, height: h, fps: Number(flag(args, "fps") ?? 30) });
@@ -92,13 +105,13 @@ async function main(argv) {
     print(r, () => [r.written.length ? `created ${target}` : `${target}: nothing to create`, ...r.written.map((f) => `  ${f}`), ...r.skipped.map((f) => `  skipped (exists): ${f}`), `next: ${cd}npm install && npm run dev`].join("\n"));
     return 0;
   }
-  const { assertProject } = await import("./chunk-SIMO6I3D.mjs");
+  const { assertProject } = await import("./chunk-TH7TK67K.mjs");
   const dir = assertProject(dirArg);
   const depth = flag(args, "depth") === "10" ? 10 : 8;
   const allowFontFallback = args.flags["allow-font-fallback"] === true;
   switch (command) {
     case "check": {
-      const { check } = await import("./chunk-MK6PL7N4.mjs");
+      const { check } = await import("./chunk-QQ3GGKDN.mjs");
       const r = await check(dir, { allowFontFallback });
       print(
         r,
@@ -117,7 +130,7 @@ async function main(argv) {
       return r.ok ? 0 : 1;
     }
     case "stamp": {
-      const { stampProject } = await import("./chunk-VI6IV6JP.mjs");
+      const { stampProject } = await import("./chunk-UMWOUQN3.mjs");
       const r = stampProject(dir);
       print(r, () => [`stamped ${r.stamped.length} element(s) in ${r.written.length} file(s)`, ...r.stamped.map((s) => `  ${s.file}: <${s.tag}> id="${s.id}"`), ...r.skipped.map((s) => `  skipped ${s.file}: ${s.reason}`)].join("\n"));
       return r.skipped.length ? 1 : 0;
@@ -126,7 +139,7 @@ async function main(argv) {
       const at = args.positional[1];
       const out = flag(args, "o", "out");
       if (!at || !out) throw new Error("usage: higgsedit frame <dir> <t> -o x.png");
-      const { frame } = await import("./chunk-4D6AXU4B.mjs");
+      const { frame } = await import("./chunk-F4CMIG5G.mjs");
       const r = await frame(dir, at, out, depth, allowFontFallback);
       print(r, () => `wrote ${r.out} (frame ${r.frame}, ${r.ms.toFixed(0)} ms)`);
       return 0;
@@ -135,7 +148,7 @@ async function main(argv) {
       const times = flag(args, "times")?.split(",").map((s) => s.trim()).filter(Boolean);
       const out = flag(args, "o", "out");
       if (!times?.length || !out) throw new Error("usage: higgsedit sheet <dir> --times 0,1,2 -o sheet.png");
-      const { sheet } = await import("./chunk-4D6AXU4B.mjs");
+      const { sheet } = await import("./chunk-F4CMIG5G.mjs");
       const r = await sheet(dir, times, out, Number(flag(args, "columns") ?? Math.min(4, times.length)), Number(flag(args, "width") ?? 480), allowFontFallback);
       print(r, () => `wrote ${r.out} (frames ${r.frames.join(", ")})`);
       return 0;
@@ -146,7 +159,7 @@ async function main(argv) {
       const encoder = flag(args, "encoder");
       if (encoder && !ENCODERS.includes(encoder)) throw new Error(`unknown --encoder ${encoder}; use ${ENCODERS.join(", ")}`);
       const crf = flag(args, "crf");
-      const { render } = await import("./chunk-4D6AXU4B.mjs");
+      const { render } = await import("./chunk-F4CMIG5G.mjs");
       const r = await render(dir, {
         out,
         depth,
@@ -172,24 +185,24 @@ async function main(argv) {
       return 0;
     }
     case "verify": {
-      const { verify } = await import("./chunk-4D6AXU4B.mjs");
+      const { verify } = await import("./chunk-F4CMIG5G.mjs");
       const r = await verify(dir, Number(flag(args, "count") ?? 12), depth, allowFontFallback);
       print(r, () => [`${r.identical ? "identical" : "DIFFERENT"}: ${r.frames.length} frames, ${r.depth}-bit, shuffled order ${r.shuffledOrder.join(",")}`, ...r.frames.map((f, i) => `  ${String(f).padStart(6)}  ${r.forward[i]}  ${r.shuffled[i] === r.forward[i] ? "=" : "\u2260"}`)].join("\n"));
       return r.identical ? 0 : 1;
     }
     case "outline": {
-      const { outline } = await import("./chunk-HTCYVKFX.mjs");
+      const { outline } = await import("./chunk-C3GSB3XZ.mjs");
       const o = await outline(dir);
       print(o, () => o.text);
       return o.ok ? 0 : 1;
     }
     case "edit": {
-      const { runEdit } = await import("./chunk-OMKZ5BXM.mjs");
+      const { runEdit } = await import("./chunk-5LTTL3Q3.mjs");
       return runEdit(dir, args, print);
     }
     case "dev": {
-      const { dev } = await import("./chunk-C6SASQHE.mjs");
-      await dev(dir, Number(flag(args, "port") ?? 4173));
+      const { dev } = await import("./chunk-2JYLVSVV.mjs");
+      await dev(dir, Number(flag(args, "port") ?? 4173), flag(args, "presets"));
       return await new Promise(() => {
       });
     }
@@ -200,7 +213,9 @@ async function main(argv) {
 }
 function exitAfterOutput(code) {
   let pending = 2;
-  const flushed = () => { if (--pending === 0) process.exit(code); };
+  const flushed = () => {
+    if (--pending === 0) process.exit(code);
+  };
   for (const stream of [process.stdout, process.stderr]) stream.write("", flushed);
 }
 patientConnects();

package/node_modules/@higgsfield/higgsedit/dist/jsx/hooks.d.ts

@@ -0,0 +1,26 @@
+import type { Accessor } from "solid-js";
+export type Ticker = {
+    /** Root playhead, seconds. */
+    time: Accessor<number>;
+    /** `round(time * fps)` at the root scene fps. */
+    frame: Accessor<number>;
+    /** Seconds since the previous tick; `1 / fps` while capturing. */
+    delta: Accessor<number>;
+    playing: Accessor<boolean>;
+    /** Makes the current frame's capture wait for `work`. A no-op in live preview. */
+    hold: (work: Promise<unknown>) => void;
+};
+/** Declaration for type-checking; a mounted project gets the host's implementation. */
+export declare function useTicker(): Ticker;
+/** Composition size and fps of the scene the caller renders in. */
+export declare function useResolution(): Accessor<{
+    width: number;
+    height: number;
+    fps: number;
+}>;
+/**
+ * Seconds on the clock of the element with this `id`: root time minus its `start` and the starts of the scenes and
+ * groups above it. That is the clock its `animate` keyframes and its `<html>` CSS animations see; `useTicker().time`
+ * stays the root playhead. Not clamped to the element's span.
+ */
+export declare function useLocalTime(id: string): Accessor<number>;

package/node_modules/@higgsfield/higgsedit/dist/jsx/index.d.ts

@@ -0,0 +1,17 @@
+export { parseTime } from "./time";
+export { useLocalTime, useResolution, useTicker } from "./hooks";
+export * from "./inspect";
+export { SVG_PREFIX, isSvgContent, isSvgTag } from "./svg";
+export type { Ticker } from "./hooks";
+export type * from "./types";
+/** The intrinsic tags that become entities. */
+export declare const INTRINSICS: readonly ["stage", "scene", "group", "rect", "text", "image", "video", "audio", "sequence", "captions", "textRange", "adjustmentLayer", "surface", "html", "shaderPaint"];
+/** Caption presets, in the order the editor lists them. */
+export declare const CAPTION_PRESETS: readonly ["classic", "whisper", "cascade", "spotlight", "paper", "guinea", "stark"];
+export declare const CAPTION_ALIGNS: readonly ["top", "center", "bottom"];
+export type Intrinsic = (typeof INTRINSICS)[number];
+export declare const isIntrinsic: (tag: string) => tag is Intrinsic;
+/** Easing names accepted in keyframes, besides `cubicBezier(...)`. */
+export declare const EASINGS: readonly ["linear", "easeIn", "easeOut", "easeInOut", "step"];
+/** `transition` types a `<sequence>` child can hand over with. */
+export declare const TRANSITION_TYPES: readonly ["dissolve", "slideFromRight", "slideFromLeft", "fadeToBlack", "fadeToWhite", "whipPan", "zoomThrough", "pixelDissolve"];

package/node_modules/@higgsfield/higgsedit/dist/jsx/inspect.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `@inspect` variables: a top-level `const` whose JSDoc carries
+ *
+ *     @inspect <type> [min=… max=… step=…] [options="a,b"] [path="Group/Label" | label="Label"]
+ *
+ * becomes a control in the editor's stage inspector. The compiler and the write-back both read the
+ * tag through `readInspectTag`, so they agree on what is a control and what is a mistake.
+ */
+export declare const INSPECT_TYPES: readonly ["number", "color", "text", "font", "boolean", "select"];
+export type InspectType = (typeof INSPECT_TYPES)[number];
+/** The value types an `@inspect` const may be initialized with (a string, number or boolean literal). */
+export type InspectValue = string | number | boolean;
+export interface InspectSpec {
+    type: InspectType;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Choices for `select`, listed as written. */
+    options?: string[];
+    /** `path="A/B/Label"` split into segments. */
+    path?: string[];
+    label?: string;
+}
+/** One `@inspect` const found in the compiled project; keyed by `file` and `name`. */
+export interface InspectDeclaration extends InspectSpec {
+    file: string;
+    name: string;
+}
+export declare class InspectTagError extends Error {
+}
+/**
+ * The control a comment asks for: undefined without an `@inspect` tag (only `/** … *\/` comments
+ * count), an `InspectTagError` when the tag is there but malformed.
+ */
+export declare function readInspectTag(comment: string): InspectSpec | undefined;
+/** Why `value` cannot initialize (or be written into) a const declared as `spec`; undefined if it can. */
+export declare function inspectMismatch(spec: InspectSpec, value: unknown): string | undefined;
+/** The control's label and the section it is filed under (empty: the ungrouped "Variables"). */
+export declare function inspectPresentation(name: string, spec: InspectSpec): {
+    label: string;
+    group: string[];
+};

package/node_modules/@higgsfield/higgsedit/dist/jsx/jsx-runtime.d.ts

@@ -0,0 +1,28 @@
+import type { JSX as SolidJSX } from "solid-js";
+import type { Intrinsic } from "./index";
+import type { AdjustmentLayerProps, AudioProps, CaptionsProps, GroupProps, HtmlProps, ImageProps, RectProps, SceneProps, SequenceProps, ShaderPaintProps, StageProps, SurfaceProps, TextProps, TextRangeProps, VideoProps } from "./types";
+/** Type-only JSX namespace; projects are compiled by babel-preset-solid against higgsedit's renderer. */
+export declare namespace JSX {
+    type Element = SolidJSX.Element;
+    interface ElementChildrenAttribute {
+        children: unknown;
+    }
+    /** Higgsedit's elements, plus HTML tags, which are only valid inside `<html>` (checked at mount). */
+    interface IntrinsicElements extends Omit<SolidJSX.IntrinsicElements, Intrinsic> {
+        stage: StageProps;
+        scene: SceneProps;
+        group: GroupProps;
+        rect: RectProps;
+        text: TextProps;
+        image: ImageProps;
+        video: VideoProps;
+        audio: AudioProps;
+        sequence: SequenceProps;
+        captions: CaptionsProps;
+        textRange: TextRangeProps;
+        adjustmentLayer: AdjustmentLayerProps;
+        surface: SurfaceProps;
+        html: HtmlProps;
+        shaderPaint: ShaderPaintProps;
+    }
+}

package/node_modules/@higgsfield/higgsedit/dist/jsx/svg.d.ts

@@ -0,0 +1,9 @@
+/** Compiled name of a shared tag used as SVG content: `<rect>` inside `<svg>` reaches the renderer as `svg:rect`. */
+export declare const SVG_PREFIX = "svg:";
+/** A tag `<html>` content creates in the SVG namespace. */
+export declare const isSvgTag: (tag: string) => boolean;
+/**
+ * Whether `tag` is SVG content rather than a higgsedit element: `rect`, `text` or `image` with an SVG-only element
+ * (`<svg>`, `<g>`, `<defs>`, `<clipPath>`…) around it in the same JSX tree. `enclosing` are the JSX tags around it.
+ */
+export declare function isSvgContent(tag: string, enclosing: Iterable<string>): boolean;

package/node_modules/@higgsfield/higgsedit/dist/jsx/time.d.ts

@@ -0,0 +1,6 @@
+import type { Time } from "./types";
+/**
+ * Seconds for a `Time`: numbers are seconds, `"30f"` is frames at `fps`, `"MM:SS"` / `"HH:MM:SS"`
+ * are clock strings (fractional seconds allowed). Returns undefined for anything unparsable.
+ */
+export declare function parseTime(value: Time | string | null | undefined, fps: number): number | undefined;