ugcinc 4.5.19 → 4.5.21

package/dist/automations/nodes/generate-video.d.ts

@@ -45,11 +45,15 @@ interface VideoModelOption {
     /** Reference-to-video variant, if one exists */
     refId?: VideoGenerationReferenceModel;
 }
+/** A single media item in a selection pool */
+interface VideoMediaItem {
+    id: string;
+    url: string;
+}
 /** Static or variable reference image input */
 interface ReferenceImageInput {
     isVariable: boolean;
-    mediaId: string | null;
-    mediaUrl: string | null;
+    mediaItems: VideoMediaItem[];
 }
 declare const ALL_VIDEO_MODELS: VideoModelOption[];
 /** @deprecated Use getImageToVideoModelId instead — I2V mode is auto-detected from image input */
@@ -76,16 +80,13 @@ declare const definition: import("./types").NodeDefinition<"generate-video", "ge
     duration: number;
     prompt: string;
     promptIsVariable: boolean;
-    imageIsVariable: boolean;
-    imageMediaId: string | null;
-    imageMediaUrl: string | null;
     inputMode: VideoInputMode;
+    imageIsVariable: boolean;
+    imageMediaItems: VideoMediaItem[];
     firstFrameIsVariable: boolean;
-    firstFrameMediaId: string | null;
-    firstFrameMediaUrl: string | null;
+    firstFrameMediaItems: VideoMediaItem[];
     lastFrameIsVariable: boolean;
-    lastFrameMediaId: string | null;
-    lastFrameMediaUrl: string | null;
+    lastFrameMediaItems: VideoMediaItem[];
     referenceImages: ReferenceImageInput[];
     outputMode: OutputMode;
     selectionMode: SelectionMode | null;
@@ -96,5 +97,5 @@ declare const _default: typeof definition & {
 };
 export default _default;
 export { isImageToVideoModel, getImageToVideoModelId, hasImageToVideoVariant, getFirstLastFrameModelId, hasFirstLastFrameVariant, getReferenceModelId, hasReferenceVariant, getAvailableInputModes, ALL_VIDEO_MODELS, getModelAspectRatios, getModelDurations, };
-export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationFirstLastFrameModel, VideoGenerationReferenceModel, VideoGenerationModel, VideoInputMode, VideoModelProvider, VideoModelTier, VideoAspectRatioOption, VideoDurationOption, VideoModelOption, ReferenceImageInput, };
+export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationFirstLastFrameModel, VideoGenerationReferenceModel, VideoGenerationModel, VideoInputMode, VideoMediaItem, VideoModelProvider, VideoModelTier, VideoAspectRatioOption, VideoDurationOption, VideoModelOption, ReferenceImageInput, };
 export type GenerateVideoNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/generate-video.js

@@ -127,17 +127,15 @@ const definition = (0, types_1.defineNode)({
         duration: 5,
         prompt: '',
         promptIsVariable: false,
-        imageIsVariable: false,
-        imageMediaId: null,
-        imageMediaUrl: null,
         inputMode: 'none',
+        // Image-to-video
+        imageIsVariable: false,
+        imageMediaItems: [],
         // First-last-frame
         firstFrameIsVariable: false,
-        firstFrameMediaId: null,
-        firstFrameMediaUrl: null,
+        firstFrameMediaItems: [],
         lastFrameIsVariable: false,
-        lastFrameMediaId: null,
-        lastFrameMediaUrl: null,
+        lastFrameMediaItems: [],
         // Reference
         referenceImages: [],
         outputMode: 'per-input',

package/dist/automations/nodes/index.d.ts

@@ -175,16 +175,13 @@ export declare const nodeDefinitions: {
         duration: number;
         prompt: string;
         promptIsVariable: boolean;
-        imageIsVariable: boolean;
-        imageMediaId: string | null;
-        imageMediaUrl: string | null;
         inputMode: import("./generate-video").VideoInputMode;
+        imageIsVariable: boolean;
+        imageMediaItems: import("./generate-video").VideoMediaItem[];
         firstFrameIsVariable: boolean;
-        firstFrameMediaId: string | null;
-        firstFrameMediaUrl: string | null;
+        firstFrameMediaItems: import("./generate-video").VideoMediaItem[];
         lastFrameIsVariable: boolean;
-        lastFrameMediaId: string | null;
-        lastFrameMediaUrl: string | null;
+        lastFrameMediaItems: import("./generate-video").VideoMediaItem[];
         referenceImages: import("./generate-video").ReferenceImageInput[];
         outputMode: import("./types").OutputMode;
         selectionMode: import("./types").SelectionMode | null;

package/dist/automations/nodes/video-composer.js

@@ -37,7 +37,8 @@ const definition = (0, types_1.defineNode)({
                 channel.segments.forEach(segment => {
                     // inputRef exists on all segments except 'text'
                     if (segment.type !== 'text') {
-                        if (segment.inputRef && !addedIds.has(segment.inputRef)) {
+                        const isVar = !('isVariable' in segment) || segment.isVariable !== false;
+                        if (segment.inputRef && !addedIds.has(segment.inputRef) && isVar) {
                             addedIds.add(segment.inputRef);
                             const inputType = segment.type === 'video' || segment.type === 'video-sequence' ? 'video'
                                 : segment.type === 'audio' ? 'audio'
@@ -52,7 +53,7 @@ const definition = (0, types_1.defineNode)({
                     }
                     // textInputRef only exists on 'text' segments
                     if (segment.type === 'text') {
-                        if (segment.textInputRef && !addedIds.has(segment.textInputRef)) {
+                        if (segment.textInputRef && !addedIds.has(segment.textInputRef) && segment.textIsVariable !== false) {
                             addedIds.add(segment.textInputRef);
                             inputs.push({
                                 id: segment.textInputRef,
@@ -87,8 +88,13 @@ const definition = (0, types_1.defineNode)({
         for (const channel of editorConfig.channels) {
             for (const segment of channel.segments) {
                 if (segment.type !== 'text') {
-                    // Media segments with inputRef
-                    if (segment.inputRef) {
+                    // Media segments - static or variable
+                    if ('isVariable' in segment && segment.isVariable === false) {
+                        const url = segment.staticMedia?.[0]?.url;
+                        if (url)
+                            sources[segment.id] = url;
+                    }
+                    else if (segment.inputRef) {
                         const url = editorConfig.previewUrls?.[segment.inputRef];
                         if (url) {
                             sources[segment.id] = url;
@@ -96,8 +102,12 @@ const definition = (0, types_1.defineNode)({
                     }
                 }
                 else {
-                    // Text segments with textInputRef
-                    if (segment.textInputRef) {
+                    // Text segments - static or variable
+                    if (segment.textIsVariable === false) {
+                        if (segment.text)
+                            textContent[segment.id] = segment.text;
+                    }
+                    else if (segment.textInputRef) {
                         const text = editorConfig.previewTextValues?.[segment.textInputRef];
                         if (text) {
                             textContent[segment.id] = text;
@@ -173,82 +183,109 @@ function transformSegment(segment, inputs) {
     let result = { ...segment };
     // Handle inputRef for media segments
     if ('inputRef' in segment && segment.inputRef) {
-        const inputKey = segment.inputRef;
-        const value = inputs[inputKey];
-        if (value === undefined || value === null) {
-            if (segment.required === false) {
-                return null; // Optional segment with missing input
-            }
-            throw new Error(`Required segment input "${inputKey}" was not provided`);
-        }
-        // Image sequence segments expect array of media values
-        if (segment.type === 'image-sequence') {
-            if (!Array.isArray(value)) {
-                throw new Error(`Image sequence expects ImageValue[] for "${inputKey}", got ${typeof value}`);
-            }
-            let items = value.map(v => v.url);
-            if (segment.itemCountMode === 'static' && segment.staticItemCount !== undefined) {
-                items = items.slice(0, segment.staticItemCount);
-            }
-            const keysToOmit = ['inputRef', 'timeMode', 'itemCountMode', 'staticItemCount'];
-            const transformed = {
-                ...omit(segment, [...keysToOmit]),
-                type: 'image-sequence',
-                source: '',
-                items,
-            };
-            result = transformed;
-        }
-        else if (segment.type === 'video-sequence') {
-            if (!Array.isArray(value)) {
-                throw new Error(`Video sequence expects VideoValue[] for "${inputKey}", got ${typeof value}`);
-            }
-            let items = value.map(v => v.url);
-            if (segment.itemCountMode === 'static' && segment.staticItemCount !== undefined) {
-                items = items.slice(0, segment.staticItemCount);
+        if ('isVariable' in segment && segment.isVariable === false) {
+            // Static: pick random from staticMedia
+            const items = segment.staticMedia;
+            if (items?.length) {
+                const pick = items[Math.floor(Math.random() * items.length)];
+                if (pick?.url) {
+                    const keysToOmit = ['inputRef', 'timeMode', 'isVariable', 'staticMedia'];
+                    if (segment.type === 'video') {
+                        result = { ...omit(segment, [...keysToOmit]), type: 'video', source: pick.url };
+                    }
+                    else if (segment.type === 'audio') {
+                        result = { ...omit(segment, [...keysToOmit]), type: 'audio', source: pick.url };
+                    }
+                    else if (segment.type === 'image') {
+                        result = { ...omit(segment, [...keysToOmit]), type: 'image', source: pick.url };
+                    }
+                }
             }
-            const keysToOmit = ['inputRef', 'timeMode', 'itemCountMode', 'staticItemCount'];
-            const transformed = {
-                ...omit(segment, [...keysToOmit]),
-                type: 'video-sequence',
-                source: '',
-                items,
-            };
-            result = transformed;
         }
         else {
-            // Single media segment (image/video/audio) - extract .url from value object
-            const mediaValue = value;
-            if (!mediaValue || typeof mediaValue !== 'object' || typeof mediaValue.url !== 'string') {
-                throw new Error(`Segment expects media value with url for "${inputKey}", got ${typeof value}`);
+            const inputKey = segment.inputRef;
+            const value = inputs[inputKey];
+            if (value === undefined || value === null) {
+                if (segment.required === false) {
+                    return null; // Optional segment with missing input
+                }
+                throw new Error(`Required segment input "${inputKey}" was not provided`);
             }
-            const source = mediaValue.url;
-            const keysToOmit = ['inputRef', 'timeMode'];
-            if (segment.type === 'video') {
-                result = { ...omit(segment, [...keysToOmit]), type: 'video', source };
+            // Image sequence segments expect array of media values
+            if (segment.type === 'image-sequence') {
+                if (!Array.isArray(value)) {
+                    throw new Error(`Image sequence expects ImageValue[] for "${inputKey}", got ${typeof value}`);
+                }
+                let items = value.map(v => v.url);
+                if (segment.itemCountMode === 'static' && segment.staticItemCount !== undefined) {
+                    items = items.slice(0, segment.staticItemCount);
+                }
+                const keysToOmit = ['inputRef', 'timeMode', 'itemCountMode', 'staticItemCount'];
+                const transformed = {
+                    ...omit(segment, [...keysToOmit]),
+                    type: 'image-sequence',
+                    source: '',
+                    items,
+                };
+                result = transformed;
             }
-            else if (segment.type === 'audio') {
-                result = { ...omit(segment, [...keysToOmit]), type: 'audio', source };
+            else if (segment.type === 'video-sequence') {
+                if (!Array.isArray(value)) {
+                    throw new Error(`Video sequence expects VideoValue[] for "${inputKey}", got ${typeof value}`);
+                }
+                let items = value.map(v => v.url);
+                if (segment.itemCountMode === 'static' && segment.staticItemCount !== undefined) {
+                    items = items.slice(0, segment.staticItemCount);
+                }
+                const keysToOmit = ['inputRef', 'timeMode', 'itemCountMode', 'staticItemCount'];
+                const transformed = {
+                    ...omit(segment, [...keysToOmit]),
+                    type: 'video-sequence',
+                    source: '',
+                    items,
+                };
+                result = transformed;
             }
-            else if (segment.type === 'image') {
-                result = { ...omit(segment, [...keysToOmit]), type: 'image', source };
+            else {
+                // Single media segment (image/video/audio) - extract .url from value object
+                const mediaValue = value;
+                if (!mediaValue || typeof mediaValue !== 'object' || typeof mediaValue.url !== 'string') {
+                    throw new Error(`Segment expects media value with url for "${inputKey}", got ${typeof value}`);
+                }
+                const source = mediaValue.url;
+                const keysToOmit = ['inputRef', 'timeMode'];
+                if (segment.type === 'video') {
+                    result = { ...omit(segment, [...keysToOmit]), type: 'video', source };
+                }
+                else if (segment.type === 'audio') {
+                    result = { ...omit(segment, [...keysToOmit]), type: 'audio', source };
+                }
+                else if (segment.type === 'image') {
+                    result = { ...omit(segment, [...keysToOmit]), type: 'image', source };
+                }
             }
         }
     }
     // Handle textInputRef for text segments
-    if (segment.type === 'text' && segment.textInputRef) {
-        const inputKey = segment.textInputRef;
-        const value = inputs[inputKey];
-        if (value === undefined || value === null) {
-            if (segment.required === false) {
-                return null;
-            }
-            throw new Error(`Required text segment input "${inputKey}" was not provided`);
+    if (segment.type === 'text') {
+        if (segment.textIsVariable === false) {
+            // Static text: use segment.text directly
+            result = { ...omit(segment, ['textInputRef', 'timeMode', 'textIsVariable']), type: 'text', source: '', text: segment.text ?? '' };
         }
-        if (typeof value !== 'string') {
-            throw new Error(`Text segment expects string for "${inputKey}", got ${typeof value}`);
+        else if (segment.textInputRef) {
+            const inputKey = segment.textInputRef;
+            const value = inputs[inputKey];
+            if (value === undefined || value === null) {
+                if (segment.required === false) {
+                    return null;
+                }
+                throw new Error(`Required text segment input "${inputKey}" was not provided`);
+            }
+            if (typeof value !== 'string') {
+                throw new Error(`Text segment expects string for "${inputKey}", got ${typeof value}`);
+            }
+            result = { ...omit(segment, ['textInputRef', 'timeMode']), type: 'text', source: '', text: value };
         }
-        result = { ...omit(segment, ['textInputRef', 'timeMode']), type: 'text', source: '', text: value };
     }
     // Handle trim inputRefs
     if (segment.startTrimInputRef) {
@@ -274,7 +311,7 @@ function transformSegment(segment, inputs) {
         }
     }
     // Remove UI-only fields
-    const uiOnlyKeys = ['timeMode', 'startTrimInputRef', 'endTrimInputRef'];
+    const uiOnlyKeys = ['timeMode', 'startTrimInputRef', 'endTrimInputRef', 'isVariable', 'staticMedia', 'textIsVariable'];
     const resultWithUiFields = result;
     for (const key of uiOnlyKeys) {
         if (key in resultWithUiFields) {

package/dist/render/types/video.d.ts

@@ -11,7 +11,7 @@
  * - previewUrls/previewTextValues: Only for UI preview
  */
 import type { FitMode, BorderRadiusConfig, TimeValue, TextStyleProperties } from './base';
-import type { DimensionPresetKey } from './element';
+import type { DimensionPresetKey, StaticMediaItem } from './element';
 /**
  * UI helper for timing mode - not sent to renderer
  */
@@ -71,6 +71,10 @@ export interface VideoEditorVideoSegment extends VideoEditorVisualSegment {
     inputRef?: string;
     /** Actual source URL (set after inputRef is resolved) */
     source?: string;
+    /** UI-only: whether this segment uses a variable input (default: true for backwards compat) */
+    isVariable?: boolean;
+    /** UI-only: static media items when isVariable is false */
+    staticMedia?: StaticMediaItem[];
     fit?: FitMode;
     speed?: number;
     volume?: number;
@@ -85,6 +89,10 @@ export interface VideoEditorAudioSegment extends VideoEditorBaseSegment {
     inputRef?: string;
     /** Actual source URL (set after inputRef is resolved) */
     source?: string;
+    /** UI-only: whether this segment uses a variable input (default: true for backwards compat) */
+    isVariable?: boolean;
+    /** UI-only: static media items when isVariable is false */
+    staticMedia?: StaticMediaItem[];
     volume?: number;
 }
 /**
@@ -96,6 +104,10 @@ export interface VideoEditorImageSegment extends VideoEditorVisualSegment {
     inputRef?: string;
     /** Actual source URL (set after inputRef is resolved) */
     source?: string;
+    /** UI-only: whether this segment uses a variable input (default: true for backwards compat) */
+    isVariable?: boolean;
+    /** UI-only: static media items when isVariable is false */
+    staticMedia?: StaticMediaItem[];
     fit?: FitMode;
     loop?: boolean;
     borderRadius?: number | BorderRadiusConfig;
@@ -112,6 +124,8 @@ export interface VideoEditorTextSegment extends VideoEditorVisualSegment, TextSt
     textInputRef?: string;
     /** Actual text content (set after textInputRef is resolved) */
     text?: string;
+    /** UI-only: whether this segment uses a variable text input (default: true for backwards compat) */
+    textIsVariable?: boolean;
 }
 /**
  * Image sequence segment (UI) - plays an array of images sequentially

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugcinc",
-  "version": "4.5.19",
+  "version": "4.5.21",
   "description": "TypeScript/JavaScript client for the UGC Inc API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",