@comfyorg/comfyui-frontend-types 1.28.3 → 1.28.5

package/index.d.ts

@@ -29,6 +29,7 @@ import { RunningTaskItem } from '../schemas/apiSchema';
 import { Settings } from '../schemas/apiSchema';
 import { Settings as Settings_2 } from '../../schemas/apiSchema';
 import { Settings as Settings_3 } from '../../../schemas/apiSchema';
+import { ShallowRef } from 'vue';
 import { StatusWsMessage } from '../schemas/apiSchema';
 import { StatusWsMessageStatus } from '../schemas/apiSchema';
 import { SystemStats } from '../schemas/apiSchema';
@@ -69,9 +70,6 @@ declare type ApiToEventType<T = ApiCalls> = {
     [K in keyof T]: K extends 'status' ? StatusWsMessageStatus : K extends 'executing' ? NodeId_2 : T[K];
 };
 
-/** A very firm array */
-declare type ArRect = [x: number, y: number, width: number, height: number];
-
 /** Wraps all properties in {@link CustomEvent}. */
 declare type AsCustomEvents<T> = {
     readonly [K in keyof T]: CustomEvent<T[K]>;
@@ -258,6 +256,7 @@ declare abstract class BaseWidget<TWidget extends IBaseWidget = IBaseWidget> imp
     computedDisabled?: boolean;
     hidden?: boolean;
     advanced?: boolean;
+    promoted?: boolean;
     tooltip?: string;
     element?: HTMLElement;
     callback?(value: any, canvas?: LGraphCanvas, node?: LGraphNode, pos?: Point, e?: CanvasPointerEvent): void;
@@ -971,7 +970,14 @@ export declare class ComfyApi extends EventTarget {
 }
 
 export declare class ComfyApp {
-    #private;
+    /**
+     * List of entries to queue
+     */
+    private queueItems;
+    /**
+     * If the queue is currently being processed
+     */
+    private processingQueue;
     /**
      * Content Clipboard
      * @type {serialized node object}
@@ -987,10 +993,15 @@ export declare class ComfyApp {
      extensionManager: ExtensionManager;
      _nodeOutputs: Record<string, any>;
      nodePreviewImages: Record<string, string[]>;
+     private rootGraphInternal;
+     /** @deprecated Use {@link rootGraph} instead */
      get graph(): LGraph;
+     get rootGraph(): LGraph | undefined;
      canvas: LGraphCanvas;
      dragOverNode: LGraphNode | null;
-     canvasEl: HTMLCanvasElement;
+     readonly canvasElRef: ShallowRef<HTMLCanvasElement | undefined, HTMLCanvasElement | undefined>;
+     get canvasEl(): HTMLCanvasElement;
+     private configuringGraphLevel;
      get configuringGraph(): boolean;
      ctx: CanvasRenderingContext2D;
      bodyTop: HTMLElement;
@@ -1001,6 +1012,7 @@ export declare class ComfyApp {
      menu: ComfyAppMenu;
      bypassBgColor: string;
      openClipspace: () => void;
+     private positionConversion?;
      /**
       * The node errors from the previous execution.
       * @deprecated Use useExecutionStore().lastNodeErrors instead
@@ -1074,12 +1086,29 @@ export declare class ComfyApp {
      static onClipspaceEditorClosed(): void;
      static copyToClipspace(node: LGraphNode): void;
      static pasteFromClipspace(node: LGraphNode): void;
+     /**
+      * Adds a handler allowing drag+drop of files onto the window to load workflows
+      */
+     private addDropHandler;
+     /**
+      * Handle keypress
+      */
+     private addProcessKeyHandler;
+     private addDrawNodeHandler;
+     /**
+      * Handles updates from the API socket
+      */
+     private addApiUpdateHandlers;
+     /** Flag that the graph is configuring to prevent nodes from running checks while its still loading */
+     private addConfigureHandler;
+     private addAfterConfigureHandler;
      /**
       * Set up the app on the page
       */
      setup(canvasEl: HTMLCanvasElement): Promise<void>;
-     resizeCanvas(): void;
+     private resizeCanvas;
      private updateVueAppNodeDefs;
+     getNodeDefs(): Promise<Record<string, ComfyNodeDef>>;
      /**
       * Registers nodes with the graph
       */
@@ -1087,6 +1116,8 @@ export declare class ComfyApp {
      registerNodeDef(nodeId: string, nodeDef: ComfyNodeDef): Promise<void>;
      registerNodesFromDefs(defs: Record<string, ComfyNodeDef>): Promise<void>;
      loadTemplateData(templateData: any): void;
+     private showMissingNodesError;
+     private showMissingModelsError;
      loadGraphData(graphData?: ComfyWorkflowJSON, clean?: boolean, restore_view?: boolean, workflow?: string | null | ComfyWorkflow, { showMissingNodesDialog, showMissingModelsDialog, checkForRerouteMigration }?: {
          showMissingNodesDialog?: boolean | undefined;
          showMissingModelsDialog?: boolean | undefined;
@@ -1544,9 +1575,9 @@ export declare class ComfyApp {
         get desiredHeight(): number;
         set desiredHeight(value: number);
         constructor(width: number, height: number);
-        static fromSize(size: ReadOnlySize): ConstrainedSize;
+        static fromSize(size: Readonly<Size>): ConstrainedSize;
         static fromRect(rect: ReadOnlyRect): ConstrainedSize;
-        setSize(size: ReadOnlySize): void;
+        setSize(size: Readonly<Size>): void;
         setValues(width: number, height: number): void;
         toSize(): Size;
     }
@@ -1731,7 +1762,7 @@ export declare class ComfyApp {
      * @param b Point b as `x, y`
      * @returns Distance between point {@link a} & {@link b}
      */
-    declare function distance(a: ReadOnlyPoint, b: ReadOnlyPoint): number;
+    declare function distance(a: Readonly<Point>, b: Readonly<Point>): number;
 
     /**
      * A DOM widget that wraps a custom HTML element as a litegraph widget.
@@ -1919,7 +1950,7 @@ export declare class ComfyApp {
         readonly subgraphNodePath: readonly NodeId[];
         /** A flattened map of all DTOs in this node network. Subgraph instances have been expanded into their inner nodes. */
         readonly nodesByExecutionId: Map<ExecutionId, ExecutableLGraphNode>;
-        /** The actual subgraph instance that contains this node, otherise undefined. */
+        /** The actual subgraph instance that contains this node, otherwise undefined. */
         readonly subgraphNode?: SubgraphNode | undefined;
         applyToGraph?(...args: CallbackParams<typeof ExecutableNodeDTO.node.applyToGraph>): CallbackReturn<typeof ExecutableNodeDTO.node.applyToGraph>;
         /** The graph that this node is a part of. */
@@ -1930,7 +1961,7 @@ export declare class ComfyApp {
             type: ISlotType;
         }[];
         /**
-         * The path to the acutal node through subgraph instances, represented as a list of all subgraph node IDs (instances),
+         * The path to the actual node through subgraph instances, represented as a list of all subgraph node IDs (instances),
          * followed by the actual original node ID within the subgraph. Each segment is separated by `:`.
          *
          * e.g. `1:2:3`:
@@ -1953,7 +1984,7 @@ export declare class ComfyApp {
         subgraphNodePath: readonly NodeId[], 
         /** A flattened map of all DTOs in this node network. Subgraph instances have been expanded into their inner nodes. */
         nodesByExecutionId: Map<ExecutionId, ExecutableLGraphNode>, 
-        /** The actual subgraph instance that contains this node, otherise undefined. */
+        /** The actual subgraph instance that contains this node, otherwise undefined. */
         subgraphNode?: SubgraphNode | undefined);
         /** Returns either the DTO itself, or the DTOs of the inner nodes of the subgraph. */
         getInnerNodes(): ExecutableLGraphNode[];
@@ -2180,6 +2211,7 @@ export declare class ComfyApp {
      * @see IWidget
      */
     declare interface IBaseWidget<TValue = boolean | number | string | object | undefined, TType extends string = string, TOptions extends IWidgetOptions<unknown> = IWidgetOptions<unknown>> {
+        [symbol: symbol]: boolean;
         linkedWidgets?: IBaseWidget[];
         name: string;
         options: TOptions;
@@ -2224,6 +2256,13 @@ export declare class ComfyApp {
         computedDisabled?: boolean;
         hidden?: boolean;
         advanced?: boolean;
+        /**
+         * This property is automatically computed on graph change
+         * and should not be changed.
+         * Promoted widgets have a colored border
+         * @see /core/graph/subgraph/proxyWidget.registerProxyWidgets
+         */
+        promoted?: boolean;
         tooltip?: string;
         callback?(value: any, canvas?: LGraphCanvas, node?: LGraphNode, pos?: Point, e?: CanvasPointerEvent): void;
         /**
@@ -2596,7 +2635,7 @@ export declare class ComfyApp {
         nameLocked?: boolean;
         pos?: Point;
         /** @remarks Automatically calculated; not included in serialisation. */
-        boundingRect: Rect;
+        boundingRect: ReadOnlyRect;
         /**
          * A list of floating link IDs that are connected to this slot.
          * This is calculated at runtime; it is **not** serialized.
@@ -2909,6 +2948,8 @@ export declare class ComfyApp {
         property?: string;
         /** If `true`, an input socket will not be created for this widget. */
         socketless?: boolean;
+        /** If `true`, the widget will not be rendered by the Vue renderer. */
+        canvasOnly?: boolean;
         values?: TValues;
         callback?: IWidget['callback'];
     }
@@ -3217,7 +3258,7 @@ export declare class ComfyApp {
         /**
          * Snaps the provided items to a grid.
          *
-         * Item positions are reounded to the nearest multiple of {@link LiteGraph.CANVAS_GRID_SIZE}.
+         * Item positions are rounded to the nearest multiple of {@link LiteGraph.CANVAS_GRID_SIZE}.
          *
          * When {@link LiteGraph.alwaysSnapToGrid} is enabled
          * and the grid size is falsy, a default of 1 is used.
@@ -3512,7 +3553,7 @@ export declare class ComfyApp {
         linkMarkerShape: LinkMarkerShape;
         links_render_mode: number;
         /** Minimum font size in pixels before switching to low quality rendering.
-         * This intializes first and if we cant get the value from the settings we default to 8px
+         * This initializes first and if we can't get the value from the settings we default to 8px
          */
         private _min_font_size_for_lod;
         get min_font_size_for_lod(): number;
@@ -3576,7 +3617,7 @@ export declare class ComfyApp {
         dirty_area?: Rect | null;
         /** @deprecated Unused */
         node_in_panel?: LGraphNode | null;
-        last_mouse: ReadOnlyPoint;
+        last_mouse: Readonly<Point>;
         last_mouseclick: number;
         graph: LGraph | Subgraph | null;
         get _graph(): LGraph | Subgraph;
@@ -3704,7 +3745,7 @@ export declare class ComfyApp {
          * Assigns a new graph to this canvas.
          */
         setGraph(newGraph: LGraph | Subgraph): void;
-        openSubgraph(subgraph: Subgraph): void;
+        openSubgraph(subgraph: Subgraph, fromNode: SubgraphNode): void;
         /**
          * @returns the visually active graph (in case there are more in the stack)
          */
@@ -3979,13 +4020,13 @@ export declare class ComfyApp {
          * @param start_dir the direction enum
          * @param end_dir the direction enum
          */
-        renderLink(ctx: CanvasRenderingContext2D, a: ReadOnlyPoint, b: ReadOnlyPoint, link: LLink | null, skip_border: boolean, flow: number | null, color: CanvasColour | null, start_dir: LinkDirection, end_dir: LinkDirection, { startControl, endControl, reroute, num_sublines, disabled }?: {
+        renderLink(ctx: CanvasRenderingContext2D, a: Readonly<Point>, b: Readonly<Point>, link: LLink | null, skip_border: boolean, flow: number | null, color: CanvasColour | null, start_dir: LinkDirection, end_dir: LinkDirection, { startControl, endControl, reroute, num_sublines, disabled }?: {
             /** When defined, render data will be saved to this reroute instead of the {@link link}. */
             reroute?: Reroute;
             /** Offset of the bezier curve control point from {@link a point a} (output side) */
-            startControl?: ReadOnlyPoint;
+            startControl?: Readonly<Point>;
             /** Offset of the bezier curve control point from {@link b point b} (input side) */
-            endControl?: ReadOnlyPoint;
+            endControl?: Readonly<Point>;
             /** Number of sublines (useful to represent vec3 or rgb) @todo If implemented, refactor calculations out of the loop */
             num_sublines?: number;
             /** Whether this is a floating link segment */
@@ -4040,6 +4081,27 @@ export declare class ComfyApp {
          * If nothing is selected, the view is fitted around all items in the graph.
          */
         fitViewToSelectionAnimated(options?: AnimationOptions): void;
+        /**
+         * Calculate new position with delta
+         */
+        private calculateNewPosition;
+        /**
+         * Apply batched node position updates
+         */
+        private applyNodePositionUpdates;
+        /**
+         * Initialize layout mutations with Canvas source
+         */
+        private initLayoutMutations;
+        /**
+         * Collect all nodes that are children of groups in the selection
+         */
+        private collectNodesInGroups;
+        /**
+         * Move group children (both nodes and non-nodes)
+         */
+        private moveGroupChildren;
+        moveChildNodesInGroupVueMode(allItems: Set<Positionable>, deltaX: number, deltaY: number): void;
     }
 
     declare interface LGraphCanvasEventMap {
@@ -4050,6 +4112,11 @@ export declare class ComfyApp {
             /** The old active graph, or `null` if there was no active graph. */
             oldGraph: LGraph | Subgraph | null | undefined;
         };
+        'subgraph-opened': {
+            subgraph: Subgraph;
+            closingGraph: LGraph;
+            fromNode: SubgraphNode;
+        };
         'litegraph:canvas': {
             subType: 'before-change' | 'after-change';
         } | {
@@ -4170,7 +4237,7 @@ export declare class ComfyApp {
         title: string;
         font?: string;
         font_size: number;
-        _bounding: Float32Array;
+        _bounding: Rectangle;
         _pos: Point;
         _size: Size;
         /** @deprecated See {@link _children} */
@@ -4190,7 +4257,8 @@ export declare class ComfyApp {
         /** Size of the group, as width,height in graph units */
         get size(): Size;
         set size(v: Size);
-        get boundingRect(): Float32Array<ArrayBufferLike>;
+        get boundingRect(): Rectangle;
+        getBounding(): Rectangle;
         get nodes(): LGraphNode[];
         get titleHeight(): number;
         get children(): ReadonlySet<Positionable>;
@@ -4396,9 +4464,9 @@ export declare class ComfyApp {
          */
         get boundingRect(): ReadOnlyRectangle;
         /** The offset from {@link pos} to the top-left of {@link boundingRect}. */
-        get boundingOffset(): ReadOnlyPoint;
-        /** {@link pos} and {@link size} values are backed by this {@link Rect}. */
-        _posSize: Float32Array;
+        get boundingOffset(): Readonly<Point>;
+        /** {@link pos} and {@link size} values are backed by this {@link Rectangle}. */
+        _posSize: Rectangle;
         _pos: Point;
         _size: Size;
         get pos(): Point;
@@ -4723,7 +4791,7 @@ export declare class ComfyApp {
         measure(out: Rect, ctx: CanvasRenderingContext2D): void;
         /**
          * returns the bounding of the object, used for rendering purposes
-         * @param out {Float32Array[4]?} [optional] a place to store the output, to free garbage
+         * @param out {Rect?} [optional] a place to store the output, to free garbage
          * @param includeExternal {boolean?} [optional] set to true to
          * include the shadow and connection points in the bounding calculation
          * @returns the bounding box in format of [topleft_cornerx, topleft_cornery, width, height]
@@ -4830,7 +4898,7 @@ export declare class ComfyApp {
         findOutputSlotByType<TReturn extends true>(type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): INodeOutputSlot;
         /**
          * returns the output (or input) slot with a given type, -1 if not found
-         * @param input uise inputs instead of outputs
+         * @param input use inputs instead of outputs
          * @param type the type of the slot to find
          * @param returnObj if the obj itself wanted
          * @param preferFreeSlot if we want a free slot (if not found, will return the first of the type anyway)
@@ -5034,6 +5102,7 @@ export declare class ComfyApp {
          * Returns `true` if the widget is visible, otherwise `false`.
          */
         isWidgetVisible(widget: IBaseWidget): boolean;
+        updateComputedDisabled(): void;
         drawWidgets(ctx: CanvasRenderingContext2D, { lowQuality, editorAlpha }: DrawWidgetsOptions): void;
         /**
          * When {@link LGraphNode.collapsed} is `true`, this method draws the node's collapsed slots.
@@ -5342,13 +5411,6 @@ export declare class ComfyApp {
         disabledPattern?: CanvasPattern | null;
     }
 
-    declare interface LinkRenderOptions {
-        color?: CanvasColour;
-        flow?: boolean;
-        skipBorder?: boolean;
-        disabled?: boolean;
-    }
-
     /** The path calculation that links follow */
     declare enum LinkRenderType {
         HIDDEN_LINK = -1,
@@ -5369,7 +5431,7 @@ export declare class ComfyApp {
         /** The last canvas 2D path that was used to render this segment */
         path?: Path2D;
         /** Centre point of the {@link path}.  Calculated during render only - can be inaccurate */
-        readonly _pos: Float32Array;
+        readonly _pos: Point;
         /**
          * Y-forward along the {@link path} from its centre point, in radians.
          * `undefined` if using circles for link centres.
@@ -5424,6 +5486,7 @@ export declare class ComfyApp {
         GROUP_FONT: string;
         WIDGET_BGCOLOR: string;
         WIDGET_OUTLINE_COLOR: string;
+        WIDGET_PROMOTED_OUTLINE_COLOR: string;
         WIDGET_ADVANCED_OUTLINE_COLOR: string;
         WIDGET_TEXT_COLOR: string;
         WIDGET_SECONDARY_TEXT_COLOR: string;
@@ -5570,9 +5633,9 @@ export declare class ComfyApp {
          * !WILL CHANGE node mode when using onTrigger (enable mode colors), onExecuted does not need this
          */
         do_add_triggers_slots: boolean;
-        /** [false!] being events, it is strongly reccomended to use them sequentially, one by one */
+        /** [false!] being events, it is strongly recommended to use them sequentially, one by one */
         allow_multi_output_for_events: boolean;
-        /** [true!] allows to create and connect a ndoe clicking with the third button (wheel) */
+        /** [true!] allows to create and connect a node clicking with the third button (wheel) */
         middle_click_slot_add_default_node: boolean;
         /** [true!] dragging a link to empty space will open a menu, add from list, search or defaults */
         release_link_on_empty_shows_menu: boolean;
@@ -5745,19 +5808,9 @@ export declare class ComfyApp {
     }
 
     declare class LitegraphLinkAdapter {
-        private graph;
-        private pathRenderer;
-        enableLayoutStoreWrites: boolean;
-        constructor(graph: LGraph);
-        /**
-         * Render a single link with all necessary data properly fetched
-         * Populates link.path for hit detection
-         */
-        renderLink(ctx: CanvasRenderingContext2D, link: LLink, context: LinkRenderContext, options?: LinkRenderOptions): void;
-        /**
-         * Convert litegraph link data to pure render format
-         */
-        private convertToLinkRenderData;
+        readonly enableLayoutStoreWrites: boolean;
+        private readonly pathRenderer;
+        constructor(enableLayoutStoreWrites?: boolean);
         /**
          * Convert LinkDirection enum to Direction string
          */
@@ -5787,14 +5840,14 @@ export declare class ComfyApp {
          * Direct rendering method compatible with LGraphCanvas
          * Converts data and delegates to pure renderer
          */
-        renderLinkDirect(ctx: CanvasRenderingContext2D, a: ReadOnlyPoint, b: ReadOnlyPoint, link: LLink | null, skip_border: boolean, flow: number | boolean | null, color: CanvasColour | null, start_dir: LinkDirection, end_dir: LinkDirection, context: LinkRenderContext, extras?: {
+        renderLinkDirect(ctx: CanvasRenderingContext2D, a: Readonly<Point>, b: Readonly<Point>, link: LLink | null, skip_border: boolean, flow: number | boolean | null, color: CanvasColour | null, start_dir: LinkDirection, end_dir: LinkDirection, context: LinkRenderContext, extras?: {
             reroute?: Reroute;
-            startControl?: ReadOnlyPoint;
-            endControl?: ReadOnlyPoint;
+            startControl?: Readonly<Point>;
+            endControl?: Readonly<Point>;
             num_sublines?: number;
             disabled?: boolean;
         }): void;
-        renderDraggingLink(ctx: CanvasRenderingContext2D, from: ReadOnlyPoint, to: ReadOnlyPoint, colour: CanvasColour, startDir: LinkDirection, endDir: LinkDirection, context: LinkRenderContext): void;
+        renderDraggingLink(ctx: CanvasRenderingContext2D, from: Readonly<Point>, to: Readonly<Point>, colour: CanvasColour, startDir: LinkDirection, endDir: LinkDirection, context: LinkRenderContext): void;
         /**
          * Calculate bounding box for a link
          * Includes padding for line width and control points
@@ -5822,7 +5875,7 @@ export declare class ComfyApp {
         };
         _data?: unknown;
         /** Centre point of the link, calculated during render only - can be inaccurate */
-        _pos: Float32Array;
+        _pos: Point;
         /** @todo Clean up - never implemented in comfy. */
         _last_time?: number;
         /** The last canvas 2D path that was used to render this link */
@@ -6062,6 +6115,8 @@ export declare class ComfyApp {
         readonly inputIndex: number;
         readonly inputPos: Point;
         constructor(network: LinkNetwork, link: LLink, toType: 'input' | 'output', fromReroute?: Reroute | undefined, dragDirection?: LinkDirection);
+        abstract canConnectToInput(inputNode: NodeLike, input: INodeInputSlot): boolean;
+        abstract canConnectToOutput(outputNode: NodeLike, output: INodeOutputSlot): boolean;
         abstract connectToInput(node: LGraphNode, input: INodeInputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
         abstract connectToOutput(node: LGraphNode, output: INodeOutputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
         abstract connectToSubgraphInput(input: SubgraphInput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
@@ -6235,7 +6290,7 @@ export declare class ComfyApp {
     };
 
     /** A point represented as `[x, y]` co-ordinates */
-    declare type Point = [x: number, y: number] | Float32Array | Float64Array;
+    declare type Point = [x: number, y: number];
 
     /**
      * An object that can be positioned, selected, and moved.
@@ -6310,21 +6365,15 @@ export declare class ComfyApp {
         readonly outputNode?: SubgraphOutputNode;
     }
 
-    /** A point represented as `[x, y]` co-ordinates that will not be modified */
-    declare type ReadOnlyPoint = readonly [x: number, y: number] | ReadOnlyTypedArray<Float32Array> | ReadOnlyTypedArray<Float64Array>;
-
     /** A rectangle starting at top-left coordinates `[x, y, width, height]` that will not be modified */
-    declare type ReadOnlyRect = readonly [x: number, y: number, width: number, height: number] | ReadOnlyTypedArray<Float32Array> | ReadOnlyTypedArray<Float64Array>;
+    declare type ReadOnlyRect = readonly [x: number, y: number, width: number, height: number] | ReadOnlyTypedArray<Float64Array>;
 
     declare type ReadOnlyRectangle = Omit<ReadOnlyTypedArray<Rectangle>, 'setHeightBottomAnchored' | 'setWidthRightAnchored' | 'resizeTopLeft' | 'resizeBottomLeft' | 'resizeTopRight' | 'resizeBottomRight' | 'resizeBottomRight' | 'updateTo'>;
 
-    /** A size represented as `[width, height]` that will not be modified */
-    declare type ReadOnlySize = readonly [width: number, height: number] | ReadOnlyTypedArray<Float32Array> | ReadOnlyTypedArray<Float64Array>;
-
-    declare type ReadOnlyTypedArray<T extends TypedArrays | TypedBigIntArrays> = Omit<Readonly<T>, 'fill' | 'copyWithin' | 'reverse' | 'set' | 'sort' | 'subarray'>;
+    declare type ReadOnlyTypedArray<T extends Float64Array> = Omit<Readonly<T>, 'fill' | 'copyWithin' | 'reverse' | 'set' | 'sort' | 'subarray'>;
 
     /** A rectangle starting at top-left coordinates `[x, y, width, height]` */
-    declare type Rect = ArRect | Float32Array | Float64Array;
+    declare type Rect = [x: number, y: number, width: number, height: number] | Float64Array;
 
     /**
      * A rectangle, represented as a float64 array of 4 numbers: [x, y, width, height].
@@ -6348,7 +6397,7 @@ export declare class ComfyApp {
          * @param height The height of the rectangle.  Default: {@link width}
          * @returns A new rectangle whose centre is at {@link x}
          */
-        static fromCentre([x, y]: ReadOnlyPoint, width: number, height?: number): Rectangle;
+        static fromCentre([x, y]: Readonly<Point>, width: number, height?: number): Rectangle;
         static ensureRect(rect: ReadOnlyRect): Rectangle;
         subarray(begin?: number, end?: number): Float64Array<ArrayBuffer>;
         /**
@@ -6357,14 +6406,14 @@ export declare class ComfyApp {
          * Updating the values of the returned object will update this rectangle.
          */
         get pos(): Point;
-        set pos(value: ReadOnlyPoint);
+        set pos(value: Readonly<Point>);
         /**
          * A reference to the size of this rectangle.
          *
          * Updating the values of the returned object will update this rectangle.
          */
         get size(): Size;
-        set size(value: ReadOnlySize);
+        set size(value: Readonly<Size>);
         /** The x co-ordinate of the top-left corner of this rectangle. */
         get x(): number;
         set x(value: number);
@@ -6410,7 +6459,7 @@ export declare class ComfyApp {
          * @param point The point to check
          * @returns `true` if {@link point} is inside this rectangle, otherwise `false`.
          */
-        containsPoint([x, y]: ReadOnlyPoint): boolean;
+        containsPoint([x, y]: Readonly<Point>): boolean;
         /**
          * Checks if {@link other} is a smaller rectangle inside this rectangle.
          * One **must** be larger than the other; identical rectangles are not considered to contain each other.
@@ -6461,9 +6510,9 @@ export declare class ComfyApp {
         /** @returns The width and height of this rectangle, as a new {@link Size}. */
         getSize(): Size;
         /** @returns The offset from the top-left of this rectangle to the point [{@link x}, {@link y}], as a new {@link Point}. */
-        getOffsetTo([x, y]: ReadOnlyPoint): Point;
+        getOffsetTo([x, y]: Readonly<Point>): Point;
         /** @returns The offset from the point [{@link x}, {@link y}] to the top-left of this rectangle, as a new {@link Point}. */
-        getOffsetFrom([x, y]: ReadOnlyPoint): Point;
+        getOffsetFrom([x, y]: Readonly<Point>): Point;
         /** Resizes the rectangle without moving it, setting its top-left corner to [{@link x}, {@link y}]. */
         resizeTopLeft(x1: number, y1: number): void;
         /** Resizes the rectangle without moving it, setting its bottom-left corner to [{@link x}, {@link y}]. */
@@ -6503,6 +6552,16 @@ export declare class ComfyApp {
         readonly fromSlotIndex: number;
         /** The reroute that the link is being connected from. */
         readonly fromReroute?: Reroute;
+        /**
+         * Capability checks used for hit-testing and validation during drag.
+         * Implementations should return `false` when a connection is not possible
+         * rather than throwing.
+         */
+        canConnectToInput(node: NodeLike, input: INodeInputSlot): boolean;
+        canConnectToOutput(node: NodeLike, output: INodeOutputSlot): boolean;
+        /** Optional: only some links support validating subgraph IO or reroutes. */
+        canConnectToSubgraphInput?(input: SubgraphInput): boolean;
+        canConnectToReroute?(reroute: Reroute): boolean;
         connectToInput(node: LGraphNode, input: INodeInputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
         connectToOutput(node: LGraphNode, output: INodeOutputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
         connectToSubgraphInput(input: SubgraphInput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
@@ -6587,7 +6646,7 @@ export declare class ComfyApp {
         /** @inheritdoc */
         _centreAngle?: number;
         /** @inheritdoc */
-        _pos: Float32Array;
+        _pos: Point;
         /** @inheritdoc */
         _dragging?: boolean;
         /** Colour of the first link that rendered this reroute */
@@ -6862,7 +6921,7 @@ export declare class ComfyApp {
     declare type SimpleApiEvents = keyof PickNevers_2<ApiEventTypes>;
 
     /** A size represented as `[width, height]` */
-    declare type Size = [width: number, height: number] | Float32Array | Float64Array;
+    declare type Size = [width: number, height: number];
 
     declare class SliderWidget extends BaseWidget<ISliderWidget> implements ISliderWidget {
         type: "slider";
@@ -7100,7 +7159,7 @@ export declare class ComfyApp {
         id: UUID;
         /** The data type this slot uses. Unlike nodes, this does not support legacy numeric types. */
         type: string;
-        /** Links connected to this slot, or `undefined` if not connected. An ouptut slot should only ever have one link. */
+        /** Links connected to this slot, or `undefined` if not connected. An output slot should only ever have one link. */
         linkIds?: LinkId[];
     }
 
@@ -7305,7 +7364,7 @@ export declare class ComfyApp {
         onPointerMove(e: CanvasPointerEvent): void;
         getLinks(): LLink[];
         decrementSlots(inputsOrOutputs: 'inputs' | 'outputs'): void;
-        measure(): ReadOnlySize;
+        measure(): Readonly<Size>;
         abstract arrange(rect: ReadOnlyRect): void;
         abstract connect(slot: INodeInputSlot | INodeOutputSlot, node: LGraphNode, afterRerouteId?: RerouteId): LLink | undefined;
         /**
@@ -7552,10 +7611,6 @@ export declare class ComfyApp {
 
     declare type TWidgetValue = IWidget['value'];
 
-    declare type TypedArrays = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
-
-    declare type TypedBigIntArrays = BigInt64Array | BigUint64Array;
-
     export { User }
 
     export { UserData }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfyorg/comfyui-frontend-types",
-  "version": "1.28.3",
+  "version": "1.28.5",
   "types": "./index.d.ts",
   "files": [
     "index.d.ts"