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

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

@@ -0,0 +1,420 @@
+import type { JSX } from "solid-js";
+/** Seconds, `"30f"` (frames at the scene fps) or `"MM:SS"` / `"HH:MM:SS"`. */
+export type Time = number | `${number}f` | `${number}:${number}` | `${number}:${number}:${number}`;
+/** Accessor props are re-applied by Solid whenever their signals change. */
+export type Value<T> = T | (() => T);
+/**
+ * How a keyframe segment moves from its value to the next one's. `step` holds the value and jumps to the next at
+ * the next keyframe's time. `cubicBezier(x1, y1, x2, y2)` takes CSS control points.
+ */
+export type Easing = "linear" | "easeIn" | "easeOut" | "easeInOut" | "step" | `cubicBezier(${string})`;
+/** `[time relative to the element's start, value, easing of the segment that starts here]`. */
+export type Keyframe<T> = readonly [Time, T] | readonly [Time, T, Easing];
+export type AnimatableProps = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    scale: number;
+    scaleX: number;
+    scaleY: number;
+    opacity: number;
+    cornerRadius: number;
+    fontSize: number;
+    /**
+     * A CSS colour. `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, `rgb()` and `rgba()` interpolate; any other colour
+     * (a name, `hsl()`) holds until the segment's end and then snaps to the next.
+     */
+    fill: string;
+    blur: number;
+    shadowBlur: number;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    strokeWidth: number;
+    maskX: number;
+    maskY: number;
+    maskWidth: number;
+    maskHeight: number;
+    /** `<text>`: px between glyphs. */
+    letterSpacing: number;
+    /** `<text>`: line height as a multiple of the font size. */
+    lineHeight: number;
+};
+/** CSS mix-blend-mode names; "normal" draws over. */
+export type BlendMode = "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+/**
+ * A shape the element and its children show through. Coordinates are the element's own (pre-transform);
+ * (x, y) is the shape's centre, default the box centre, and width/height default to the box.
+ * With `src`, a matte is used instead of a shape: a `.mask` file (`higgsedit segment`), or any video as a luma
+ * matte; `invert` and `feather` apply.
+ */
+export type Mask = {
+    /**
+     * A `.mask` file (1-bit), or a video whose luma is the alpha (white shows, black cuts, grey is partial).
+     * Fitted into the box the way the element fits its footage. Its frames follow
+     * source time on a `<video>` (so it stays on the footage it was made from, whatever `sourceIn`; a matte video's
+     * timestamps are source seconds), and the element's own clock from the matte's first frame elsewhere.
+     */
+    src?: string;
+    shape?: "rectangle" | "ellipse" | "path";
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    /** Degrees, clockwise, about (x, y). */
+    rotation?: number;
+    /** Rectangle only. */
+    cornerRadius?: number;
+    /** Edge softness in px. */
+    feather?: number;
+    /** Show what lies outside the shape instead. */
+    invert?: boolean;
+    /** Path only: SVG path data drawn from (x, y); width/height do not scale it. */
+    d?: string;
+};
+/** A filter in an element's `effects`. Units: "blur" in px, "hueRotate" in degrees, every other type a 0–1 amount. */
+export type EffectType = "blur" | "hueRotate" | "brightness" | "contrast" | "grayscale" | "invert" | "saturate" | "sepia" | "opacity";
+/** One filter over the element's rendered pixels (its own and its children's, as one layer). */
+export type Effect = {
+    type: EffectType;
+    /** brightness, contrast and saturate: 1 leaves the picture as it is, 0 is black, grey and grey. */
+    value: number;
+    /** Keyframes of `value` on the element's clock. */
+    animate?: {
+        value?: readonly Keyframe<number>[];
+    };
+    /**
+     * Limits the effect to the mask; the picture is untouched outside it. Under "opacity" it is a cut-out:
+     * outside the mask goes transparent.
+     */
+    mask?: Mask;
+    hidden?: boolean;
+};
+export type ColorStop = {
+    /** 0–1 along the gradient. */
+    offset: number;
+    /** Any CSS color. */
+    color: string;
+    /** 0–1, default 1. */
+    opacity?: number;
+};
+/** A gradient across the element's box. */
+export type Gradient = {
+    /** Linear runs across the box; radial runs from its centre to half its longer side. */
+    type: "linear" | "radial";
+    /** Degrees, clockwise; 0 runs left to right. Linear only. */
+    rotation?: number;
+    stops: readonly ColorStop[];
+};
+/** A CSS color or a gradient. */
+export type Paint = string | Gradient;
+/** The last three are text only: they reveal a `<text>`'s glyphs rather than move its box. */
+export type MotionPreset = "fade" | "grow" | "shrink" | "blur" | "slide-left" | "slide-right" | "slide-up" | "slide-down" | "spin" | "twist" | "appear-word" | "appear-character" | "scramble";
+/** A preset animation at the element's start (`enter`) or end (`exit`), on top of `animate`. */
+export type Motion = {
+    preset: MotionPreset;
+    /** Default 0.5 s; clamped to the element's length. */
+    duration?: Time;
+    /** Default linear. */
+    easing?: Easing;
+    /** Start on the element's clock; default its start (enter) or its end minus `duration` (exit). */
+    at?: Time;
+    /**
+     * Edge values per channel (`opacity`, `scale`, `offsetX`/`offsetY` in box widths/heights, `rotation`
+     * in degrees, `blur` in px); other keys are kept for tools.
+     */
+    params?: Readonly<Record<string, number | string>>;
+};
+export type Animate = {
+    readonly [K in keyof AnimatableProps]?: readonly Keyframe<AnimatableProps[K]>[];
+};
+type Identity = {
+    /** Unique within the project; how the UI and write-back address this element. */
+    id?: string;
+    name?: string;
+    /** Editor-only: the editor will not move, trim or edit it. Rendering ignores it. */
+    locked?: boolean;
+};
+/** On the parent scene's or group's clock, which starts at the parent's `start`. */
+type Timing = {
+    start?: Value<Time>;
+    end?: Value<Time>;
+};
+/** How an element follows its parent's box when that box is not its authored size. Default `left`. */
+export type ConstrainX = "left" | "right" | "center" | "stretch" | "scale";
+/** As `ConstrainX`, vertically. Default `top`. */
+export type ConstrainY = "top" | "bottom" | "center" | "stretch" | "scale";
+type Transform = {
+    x?: Value<number>;
+    y?: Value<number>;
+    width?: Value<number>;
+    height?: Value<number>;
+    /**
+     * When the parent's box differs from its authored size (its width or height is keyframed, or it is
+     * itself constrained): `right` keeps the gap to the right edge, `center` the offset from the middle,
+     * `stretch` both gaps (the width changes), `scale` everything in proportion.
+     */
+    constrainX?: ConstrainX;
+    constrainY?: ConstrainY;
+    /** Pivot for rotation and scale, as a fraction of the box. Default 0 (top-left). */
+    anchorX?: Value<number>;
+    anchorY?: Value<number>;
+    /** Degrees, clockwise. */
+    rotation?: Value<number>;
+    scale?: Value<number>;
+    scaleX?: Value<number>;
+    scaleY?: Value<number>;
+    opacity?: Value<number>;
+    hidden?: Value<boolean>;
+    /**
+     * Editor preview only: play this element and everything inside it from a cached render. Unset, the editor does
+     * so for heavy content (`<html>`, shaders, blur) once the render is ready; `false` always draws it live. Renders
+     * and exports always draw it live.
+     */
+    prerender?: boolean;
+    animate?: Animate;
+    enter?: Motion | readonly Motion[];
+    exit?: Motion | readonly Motion[];
+    /** Gaussian blur radius in px, applied to the element and its children. */
+    blur?: Value<number>;
+    shadowColor?: Value<string>;
+    shadowBlur?: Value<number>;
+    shadowOffsetX?: Value<number>;
+    shadowOffsetY?: Value<number>;
+    /** Outline color; on text it grows outward by `strokeWidth`. */
+    stroke?: Value<string>;
+    strokeWidth?: Value<number>;
+    /** Clip children to this element's box (rounded by `cornerRadius` on rects). */
+    clip?: Value<boolean>;
+    /** How the element (with its children, as one layer) mixes with what is below. */
+    blend?: Value<BlendMode>;
+    mask?: Value<Mask>;
+    /** Filters over the element and its children, applied in order. */
+    effects?: Value<readonly Effect[]>;
+};
+type Children = {
+    children?: JSX.Element;
+};
+/** How a `<sequence>` child hands over to the clip after it. */
+export type TransitionType = "dissolve" | "slideFromRight" | "slideFromLeft" | "fadeToBlack" | "fadeToWhite" | "whipPan" | "zoomThrough" | "pixelDissolve";
+/** Which way the picture travels in a `whipPan`. */
+export type TransitionDirection = "left" | "right" | "up" | "down";
+/** A transition into the next clip, set on the outgoing clip; `{}` is a 1 s dissolve. */
+export type TransitionSpec = {
+    /** Default "dissolve". With `wgsl`, what plays where WebGPU can't run it. */
+    type?: TransitionType;
+    /** Length, centred on the cut. Default 0.4 s for whipPan, 0.6 s for zoomThrough, else 1 s. */
+    duration?: Time;
+    /** whipPan: which way both clips travel. Default "left". */
+    direction?: TransitionDirection;
+    /**
+     * A custom transition: a WGSL `@fragment fn main(@location(0) uv: vec2f) -> @location(0) vec4f` that mixes
+     * `sampleFrom(uv)` and `sampleTo(uv)` by `globals.progress` (0 → 1). uv spans the sequence's box. Output is premultiplied.
+     */
+    wgsl?: string;
+    /** Values for the WGSL's `@group(1)` uniforms, by name (as on `<shaderPaint>`). */
+    uniforms?: ShaderUniforms;
+};
+/** Valid on direct children of `<sequence>`; `null` is no transition. */
+type Transitioning = {
+    transition?: TransitionSpec | null;
+};
+export type Fit = "cover" | "contain" | "fill";
+export type TextAlign = "left" | "center" | "right";
+/** Casing applied when drawing; the text stays as written. */
+export type TextCase = "original" | "upper" | "lower";
+/** Where the lines sit in the box: its top, centre or foot, or (`alphabetic`) the first baseline on the box's top edge. */
+export type TextBaseline = "top" | "middle" | "bottom" | "alphabetic";
+export type StageProps = Identity & Children;
+export type SceneProps = Identity & Timing & Children & {
+    width?: number;
+    height?: number;
+    fps?: number;
+    fill?: Value<string>;
+};
+export type GroupProps = Identity & Timing & Transform & Transitioning & Children;
+/** Clips that play back to back on its parent's clock; it has no timing or transform of its own. */
+export type SequenceProps = Identity & Children;
+export type RectProps = Identity & Timing & Transform & Transitioning & Children & {
+    fill?: Value<Paint>;
+    cornerRadius?: Value<number>;
+};
+export type TextProps = Identity & Timing & Transform & Transitioning & {
+    fill?: Value<Paint>;
+    fontSize?: Value<number>;
+    fontFamily?: Value<string>;
+    fontWeight?: Value<number | "normal" | "bold">;
+    align?: Value<TextAlign>;
+    lineHeight?: Value<number>;
+    fontStyle?: Value<"normal" | "italic">;
+    /** Extra px between glyphs; negative tightens. */
+    letterSpacing?: Value<number>;
+    textCase?: Value<TextCase>;
+    /** Default `top`. Means something once `height` fixes the box. */
+    textBaseline?: Value<TextBaseline>;
+    /** The text, plus any `<textRange>` children. */
+    children?: JSX.Element;
+};
+/**
+ * A style override for characters `start` (inclusive) to `end` (exclusive, default the end) of its parent
+ * `<text>`, indexed into the text as written. Unset props inherit the text's; later ranges win where they overlap.
+ */
+export type TextRangeProps = Identity & {
+    start: Value<number>;
+    end?: Value<number>;
+    fill?: Value<string>;
+    fontSize?: Value<number>;
+    fontFamily?: Value<string>;
+    fontWeight?: Value<number | "normal" | "bold">;
+    fontStyle?: Value<"normal" | "italic">;
+    letterSpacing?: Value<number>;
+    textCase?: Value<TextCase>;
+};
+export type ImageProps = Identity & Timing & Transform & Transitioning & Children & {
+    src: Value<string>;
+    fit?: Value<Fit>;
+    /** Rounds the box; the picture is clipped to it. */
+    cornerRadius?: Value<number>;
+};
+type Sound = {
+    /** Where playback begins in the source (trims the head). */
+    sourceIn?: Value<Time>;
+    /** Linear gain, 1 = unity. */
+    volume?: Value<number>;
+    muted?: Value<boolean>;
+    /** Seconds of linear gain ramp from silence at the clip's start. */
+    fadeIn?: Value<number>;
+    /** Seconds of linear gain ramp to silence at the clip's end. */
+    fadeOut?: Value<number>;
+    /** Playback rate, > 0: source time advances `speed` × element time from `sourceIn`. */
+    speed?: Value<number>;
+    /** Time-stretch the sound so its pitch holds (default); false plays it like tape, pitch moving with speed. */
+    preservePitch?: Value<boolean>;
+    /**
+     * `id` of another video or audio: this element is placed so the two recordings coincide, by
+     * cross-correlating their audio (replaces `start`). Without `sourceIn`/`end` it covers the target's window.
+     */
+    syncTo?: string;
+};
+export type VideoProps = Identity & Timing & Transform & Transitioning & Sound & Children & {
+    src: Value<string>;
+    fit?: Value<Fit>;
+    /** Rounds the box; the picture is clipped to it. */
+    cornerRadius?: Value<number>;
+};
+/** A `<shaderPaint>` uniform value: f32, vec2f–vec4f, or a CSS colour (vec3f rgb, vec4f with alpha 1). */
+export type ShaderUniform = number | readonly number[] | string;
+export type ShaderUniforms = {
+    readonly [name: string]: ShaderUniform;
+};
+/**
+ * A WGSL fragment shader painted into its parent's box. As the first child of a `<video>` or `<image>` it
+ * reads that element's picture (`sampleSource(uv)`, fit applied) and the picture shows only through it;
+ * anywhere else it runs procedurally (`sampleSource` is transparent) over what the parent drew. Entry point:
+ * `@fragment fn main(@location(0) uv: vec2f) -> @location(0) vec4f`, premultiplied output, `uv` 0..1 over
+ * the box. `globals.time` is the parent's local seconds, `globals.resolution` its box in px.
+ */
+export type ShaderPaintProps = Identity & {
+    wgsl: Value<string>;
+    /** Values for the shader's `@group(1)` uniforms, by declared name; missing ones read as zero. */
+    uniforms?: Value<ShaderUniforms>;
+    opacity?: Value<number>;
+    hidden?: Value<boolean>;
+};
+/** Caption looks: placement, type, grouping and how the spoken word is marked. */
+export type CaptionPreset = "classic" | "whisper" | "cascade" | "spotlight" | "paper" | "guinea" | "stark";
+export type CaptionAlign = "top" | "center" | "bottom";
+/**
+ * Word-timed captions from a transcript file (`.srt`, `.vtt`, or word-timed `.json` as `higgsedit transcribe`
+ * writes). Transcript time is source time: advance `start` with `sourceIn` (and `end` with `sourceOut`)
+ * so the words stay on the audio.
+ */
+export type CaptionsProps = Identity & Timing & Transform & {
+    src: Value<string>;
+    /** Default "classic". */
+    preset?: Value<CaptionPreset>;
+    /** The preset's colour slots in order (spotlight: highlight; guinea: three word colours); alpha ignored. */
+    colors?: Value<readonly string[]>;
+    /** Vertical anchor of the caption block; default per preset (whisper and cascade: bottom). */
+    verticalAlign?: Value<CaptionAlign>;
+    /** Nudge in px on top of the preset placement. */
+    offsetX?: Value<number>;
+    offsetY?: Value<number>;
+    /** Transcript second the captions start from. */
+    sourceIn?: Value<Time>;
+    /** Transcript second the captions stop at. */
+    sourceOut?: Value<Time>;
+    /** Overrides of the preset's type. */
+    fill?: Value<string>;
+    fontSize?: Value<number>;
+    fontFamily?: Value<string>;
+    fontWeight?: Value<number | "normal" | "bold">;
+    align?: Value<TextAlign>;
+    lineHeight?: Value<number>;
+    fontStyle?: Value<"normal" | "italic">;
+};
+/** What an adjustment layer can keyframe: its transform. */
+export type AdjustmentAnimatableProps = Pick<AnimatableProps, "x" | "y" | "width" | "height" | "rotation" | "scale" | "scaleX" | "scaleY"> & {
+    offsetX: number;
+    offsetY: number;
+};
+/**
+ * Draws nothing: while its own start/end window lasts, its transform composes onto the sibling just before
+ * it (the clip drawn directly beneath). As the first child it has no sibling to act on and does nothing.
+ */
+export type AdjustmentLayerProps = Identity & Timing & {
+    x?: Value<number>;
+    y?: Value<number>;
+    /** Px, on top of `x`/`y`. */
+    offsetX?: Value<number>;
+    offsetY?: Value<number>;
+    /** Never drawn: the box rotation and scale pivot about (its centre). Default the parent's size. */
+    width?: Value<number>;
+    height?: Value<number>;
+    /** Degrees, clockwise, about the box centre. */
+    rotation?: Value<number>;
+    /** About the box centre; overrides `scaleX`/`scaleY`. */
+    scale?: Value<number>;
+    scaleX?: Value<number>;
+    scaleY?: Value<number>;
+    /** Disables the layer; the clip below is left alone. */
+    hidden?: Value<boolean>;
+    animate?: {
+        readonly [K in keyof AdjustmentAnimatableProps]?: readonly Keyframe<AdjustmentAnimatableProps[K]>[];
+    };
+    enter?: Motion | readonly Motion[];
+    exit?: Motion | readonly Motion[];
+};
+/** What a `ref` on a higgsedit element receives. */
+export interface ProjectNode<E = null> {
+    readonly tag: string;
+    /** A `<surface>`'s canvas, an `<html>`'s content root; null on other elements and where there is no DOM. */
+    readonly element: E | null;
+}
+export type SurfaceCanvas = HTMLCanvasElement | OffscreenCanvas;
+/**
+ * A canvas the project draws into, stretched over the box every frame. The canvas is sized to `width`×`height`
+ * when they are set; draw from an effect (`useTicker` time keeps renders frame-accurate), not from the ref call.
+ */
+export type SurfaceProps = Identity & Timing & Transform & Transitioning & {
+    /** Rounds the box; the picture is clipped to it. */
+    cornerRadius?: Value<number>;
+    ref?: ProjectNode<SurfaceCanvas> | ((node: ProjectNode<SurfaceCanvas>) => void);
+};
+/**
+ * Renders its HTML children as the box's picture (Chrome's html-in-canvas), with the box as the layout viewport. Reactive like the rest of
+ * the project; `<img>` sources resolve like media `src`. `<canvas>`, `<video>` and `<audio>` are not allowed inside.
+ */
+export type HtmlProps = Identity & Timing & Transform & Transitioning & {
+    /** Rounds the box; the content is clipped to it. */
+    cornerRadius?: Value<number>;
+    ref?: ProjectNode<HTMLElement> | ((node: ProjectNode<HTMLElement>) => void);
+    children?: JSX.Element;
+};
+/** Sound with no picture: music beds, voice-over, effects. */
+export type AudioProps = Identity & Timing & Sound & {
+    src: Value<string>;
+    hidden?: Value<boolean>;
+};
+export {};

package/node_modules/@higgsfield/higgsedit/package.json

@@ -1,37 +1,45 @@
 {
   "name": "@higgsfield/higgsedit",
-  "version": "0.1.0-beta.4",
-  "description": "higgsedit: the CLI for code-as-document video projects (init, check, frame, render, edit, dev)",
-  "engines": {
-    "node": ">=22.12.0"
-  },
+  "version": "0.2.0",
+  "description": "Make videos in code: create, preview, edit and render TSX video projects from the command line",
+  "keywords": [
+    "video",
+    "video-editor",
+    "video-editing",
+    "motion-graphics",
+    "render",
+    "cli",
+    "tsx",
+    "jsx",
+    "ffmpeg"
+  ],
+  "author": "Higgsfield",
   "type": "module",
   "bin": {
     "higgsedit": "./dist/higgsedit.mjs"
   },
   "exports": {
+    "./jsx": {
+      "types": "./dist/jsx/index.d.ts"
+    },
+    "./jsx/jsx-runtime": {
+      "types": "./dist/jsx/jsx-runtime.d.ts"
+    },
+    "./jsx/jsx-dev-runtime": {
+      "types": "./dist/jsx/jsx-runtime.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
     "README.md"
   ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
   "dependencies": {
     "esbuild": "0.28.2",
-    "playwright-core": "1.63.0"
-  },
-  "devDependencies": {
-    "solid-js": "1.9.16",
-    "tsx": "4.23.15",
-    "typescript": "7.0.2",
-    "@higgsedit/encoder": "0.1.0",
-    "@higgsedit/runtime": "0.1.0",
-    "@higgsedit/sam2": "0.1.0",
-    "@higgsedit/writeback": "0.1.0",
-    "@higgsedit/jsx": "0.1.0",
-    "@higgsedit/reconciler": "0.1.0"
-  },
-  "scripts": {
-    "build": "tsx scripts/build.ts"
+    "playwright-core": "1.63.0",
+    "solid-js": "1.9.16"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higgsfield/video-editor-mcp",
-  "version": "1.0.7",
+  "version": "1.1.1-dev.0",
   "description": "Higgsfield Video Editor as a local MCP server over stdio: edits TSX video projects on this machine with the higgsedit CLI and serves the editor panel.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -21,14 +21,15 @@
   "dependencies": {
     "esbuild": "0.28.2",
     "playwright-core": "1.63.0",
-    "@higgsfield/higgsedit": "0.1.0-beta.4"
+    "solid-js": "1.9.16",
+    "@higgsfield/higgsedit": "0.2.0"
   },
   "bundleDependencies": [
     "@higgsfield/higgsedit"
   ],
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "next"
   },
   "keywords": [
     "mcp",

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "higgsfield-video-editor-local",
-  "version": "1.0.7",
+  "version": "1.1.1-dev.0",
   "description": "Edit and render video projects on your Mac with Higgsfield. Arrange clips, add text, audio and motion graphics, preview your timeline in the interactive editor, and render finished videos. Generate images and videos in the editor by connecting your Higgsfield account.",
   "author": {
     "name": "Higgsfield AI, Inc."

package/plugin/plugin.json

@@ -37,5 +37,5 @@
       }
     }
   },
-  "version": "1.0.7"
+  "version": "1.1.1-dev.0"
 }

package/plugin/skills/video-editing/references/caption-titling.md

@@ -23,7 +23,7 @@ higgsedit fonts add PROJECT "Inter:700"
 ```
 
 `await p.add("Face.ttf")` returns a font handle. `typography: {fontAssetId: face.id}`
-opts into native shaping; registered legacy text uses `fontFamily`.
+opts into native shaping; other text uses `fontFamily`.
 
 Typography options include variable `axes`, OpenType `features`, `script`,
 `language`, `direction: ltr|rtl`, `bend: {amplitude, wavelength, phase, stretch}`

package/plugin/skills/video-editing/references/local-setup.md

@@ -15,9 +15,9 @@ node "$cli" install-plugin
 If the registry is unreachable or denies the package, report the error. Never
 substitute a different package or bypass the registry. Fix a failed doctor check.
 Reload the desktop app to discover plugin skills, then start a new chat for its
-tools. If an older standalone `higgsfield-use-video-editor` MCP registration is
-also present, inspect it and remove that old registration before using the plugin
-to avoid duplicate tools. Do not remove an entry with a different configuration.
+tools. If a standalone `higgsfield-use-video-editor` MCP registration is also
+present, inspect it and remove it before using the plugin to avoid duplicate
+tools. Do not remove an entry with a different configuration.
 
 The npm install's launcher checks for updates in the background at startup, at
 most once per hour. Server, UI, Higgsedit and the registered plugin bundle update