ugcinc 4.1.0 → 4.1.2

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

@@ -31,26 +31,32 @@ const definition = (0, types_1.defineNode)({
         if (editorConfig) {
             editorConfig.channels.forEach(channel => {
                 channel.segments.forEach(segment => {
-                    if (segment.inputRef && !addedIds.has(segment.inputRef)) {
-                        addedIds.add(segment.inputRef);
-                        const inputType = segment.type === 'video' ? 'video'
-                            : segment.type === 'audio' ? 'audio'
-                                : 'image';
-                        inputs.push({
-                            id: segment.inputRef,
-                            type: inputType,
-                            isArray: false,
-                            required: segment.required ?? true,
-                        });
+                    // inputRef exists on all segments except 'text'
+                    if (segment.type !== 'text') {
+                        if (segment.inputRef && !addedIds.has(segment.inputRef)) {
+                            addedIds.add(segment.inputRef);
+                            const inputType = segment.type === 'video' || segment.type === 'video-sequence' ? 'video'
+                                : segment.type === 'audio' ? 'audio'
+                                    : 'image';
+                            inputs.push({
+                                id: segment.inputRef,
+                                type: inputType,
+                                isArray: segment.type === 'image-sequence' || segment.type === 'video-sequence',
+                                required: segment.required ?? true,
+                            });
+                        }
                     }
-                    if (segment.textInputRef && !addedIds.has(segment.textInputRef)) {
-                        addedIds.add(segment.textInputRef);
-                        inputs.push({
-                            id: segment.textInputRef,
-                            type: 'text',
-                            isArray: false,
-                            required: segment.required ?? true,
-                        });
+                    // textInputRef only exists on 'text' segments
+                    if (segment.type === 'text') {
+                        if (segment.textInputRef && !addedIds.has(segment.textInputRef)) {
+                            addedIds.add(segment.textInputRef);
+                            inputs.push({
+                                id: segment.textInputRef,
+                                type: 'text',
+                                isArray: false,
+                                required: segment.required ?? true,
+                            });
+                        }
                     }
                 });
             });
@@ -67,5 +73,45 @@ const definition = (0, types_1.defineNode)({
             ],
         };
     },
+    resolvePreview: (config) => {
+        const editorConfig = config?.videoEditor;
+        if (!editorConfig)
+            return null;
+        const sources = {};
+        const textContent = {};
+        // Resolve segments: inputRef/textInputRef -> segment.id
+        for (const channel of editorConfig.channels) {
+            for (const segment of channel.segments) {
+                if (segment.type !== 'text') {
+                    // Media segments with inputRef
+                    if (segment.inputRef) {
+                        const url = editorConfig.previewUrls?.[segment.inputRef];
+                        if (url) {
+                            sources[segment.id] = url;
+                        }
+                    }
+                }
+                else {
+                    // Text segments with textInputRef
+                    if (segment.textInputRef) {
+                        const text = editorConfig.previewTextValues?.[segment.textInputRef];
+                        if (text) {
+                            textContent[segment.id] = text;
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            renderConfig: {
+                width: editorConfig.width,
+                height: editorConfig.height,
+                fps: editorConfig.fps,
+                channels: editorConfig.channels,
+            },
+            sources,
+            textContent,
+        };
+    },
 });
 exports.default = definition;

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

@@ -1,27 +1,10 @@
-/**
- * Supported platforms for video import
- * Note: YouTube is not yet implemented
- */
 export type VideoImportPlatform = 'youtube' | 'tiktok' | 'instagram';
-/**
- * Video quality options for video import
- */
 export type VideoImportQuality = '360' | '480' | '720' | '1080' | '1440' | '2160';
-/**
- * Video Import node configuration - imports videos from social media platforms
- * Note: URL is received via input port, not stored in config
- */
-export interface VideoImportNodeConfig {
-    /** Platform to import from */
-    platform: VideoImportPlatform;
-    /** Video quality preference */
-    videoQuality?: VideoImportQuality;
-}
 declare const definition: import("./types").NodeDefinition<"source", {
     platform: VideoImportPlatform;
     videoQuality: VideoImportQuality;
     outputMode: "per-input";
     selectionMode: "random";
-}>;
+}, false>;
 export default definition;
-export type VideoImportConfig = typeof definition.defaults;
+export type VideoImportNodeConfig = typeof definition.defaults;

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

@@ -16,22 +16,8 @@ const definition = (0, types_1.defineNode)({
         selectionMode: 'random',
     },
     computePorts: () => ({
-        inputs: [
-            {
-                id: 'url',
-                type: 'text',
-                isArray: false,
-                required: true,
-            },
-        ],
-        outputs: [
-            {
-                id: 'video',
-                type: 'video',
-                isArray: false,
-                required: true,
-            },
-        ],
+        inputs: [{ id: 'url', type: 'text', isArray: false, required: true }],
+        outputs: [{ id: 'video', type: 'video', isArray: false, required: true }],
     }),
 });
 exports.default = definition;

package/dist/automations/types.d.ts

@@ -3,21 +3,8 @@
  *
  * Core types for the automation system including ports, selection, and output modes.
  */
-import type { ObjectSchemaField } from './nodes/types';
-import type { VideoEditorNodeConfig, ImageEditorNodeConfig } from '../render/types';
-import type { ManualTriggerNodeConfig } from './nodes/manual-trigger';
-import type { RecurrenceNodeConfig } from './nodes/recurrence';
-import type { OutputNodeConfig } from './nodes/output';
-import type { AccountNodeConfig } from './nodes/account';
-import type { AutoPostNodeConfig } from './nodes/auto-post';
-import type { SaveToMediaNodeConfig } from './nodes/save-to-media';
-import type { VideoImportNodeConfig } from './nodes/video-import';
-import type { RandomRouteNodeConfig } from './nodes/random-route';
-import type { BranchNodeConfig } from './nodes/branch';
-import type { AutoCaptionNodeConfig } from './nodes/auto-caption';
-import type { ScreenshotAnimationConfig } from './nodes/screenshot-animation';
-import type { CreateDmNodeConfig } from './nodes/create-dm';
-import type { CollectNodeConfig } from './nodes/collect';
+import type { ObjectSchemaField, SelectionMode, OutputMode, NodeCategory } from './nodes/types';
+import type { NodeType, UserCreatableNodeType, WorkflowConfig, InternalNodeType } from './nodes';
 /**
  * Media type for automation nodes
  */
@@ -37,26 +24,6 @@ export interface EnumOption {
  * Format a port type for display (e.g., 'image' with isArray=true -> 'image[]')
  */
 export declare function formatPortType(type: BasePortType | BasePortType[], isArray: boolean): string;
-/**
- * Selection order configuration for media nodes
- */
-export type SelectionMode = 'random' | 'sequential';
-export type ExhaustionBehavior = 'restart' | 'error';
-export interface SelectionConfig {
-    mode?: SelectionMode;
-    enforceUniqueness?: boolean;
-    exhaustionBehavior?: ExhaustionBehavior;
-}
-export interface SelectionState {
-    usedIndices: number[];
-    currentIndex: number;
-}
-/**
- * Output mode for source nodes (image, video, audio, text)
- * - 'per-input': Generate a unique value for each consumer input (default)
- * - 'single': Use the same value for all consumer inputs
- */
-export type OutputMode = 'per-input' | 'single';
 /**
  * Standard node output format.
  * All nodes output their values in the _values array.
@@ -101,37 +68,14 @@ export interface ResolvedPorts {
     inputs: ResolvedPort[];
     outputs: ResolvedPort[];
 }
+export type { NodeType, UserCreatableNodeType, NodeConfig, WorkflowConfig, InternalNodeType, NodeDefinition } from './nodes';
+export { nodeDefinitions, internalNodeTypes } from './nodes';
 /**
- * Node types array for runtime use
- */
-export declare const NodeTypes: readonly ["social-audio", "text", "media", "video-import", "image-composer", "video-composer", "generate-image", "generate-video", "custom-model", "llm", "passthrough", "manual-trigger", "recurrence", "compose-workflow", "account", "auto-post", "save-to-media", "deduplicate", "for-each", "for-each-value", "transcript", "auto-caption", "screenshot-animation", "random", "random-route", "branch", "if", "not", "create-dm", "collect", "destructure"];
-/**
- * Node type enum derived from NodeTypes const array
- * This is the canonical type - use this instead of the string union NodeTypeEnum
- */
-export type NodeType = typeof NodeTypes[number];
-/**
- * User-creatable node types (excludes internal executor types like 'for-each-value')
- * These are the nodes that appear in the node picker and have definitions.
- */
-export declare const UserCreatableNodeTypes: readonly ["social-audio", "text", "media", "video-import", "image-composer", "video-composer", "generate-image", "generate-video", "custom-model", "llm", "passthrough", "manual-trigger", "recurrence", "compose-workflow", "account", "auto-post", "save-to-media", "deduplicate", "for-each", "transcript", "auto-caption", "screenshot-animation", "random", "random-route", "branch", "if", "not", "create-dm", "collect", "destructure"];
-/**
- * Type for user-creatable nodes only
+ * Pre-computed node definition with static ports.
+ * Returned by getAllNodes() and getNodeByType() for consumer convenience.
+ * Ports are pre-computed from the node's defaults - consumers don't need to call computePorts.
  */
-export type UserCreatableNodeType = typeof UserCreatableNodeTypes[number];
-/**
- * @deprecated Use NodeType instead - this is a duplicate string union
- */
-export type NodeTypeEnum = 'social-audio' | 'text' | 'media' | 'video-import' | 'image-composer' | 'video-composer' | 'generate-image' | 'generate-video' | 'custom-model' | 'llm' | 'passthrough' | 'manual-trigger' | 'recurrence' | 'compose-workflow' | 'account' | 'auto-post' | 'save-to-media' | 'deduplicate' | 'for-each' | 'for-each-value' | 'random' | 'random-route' | 'branch' | 'if' | 'not' | 'transcript' | 'auto-caption' | 'screenshot-animation' | 'create-dm' | 'collect' | 'destructure';
-/**
- * Functional category for automation nodes
- * - trigger: Nodes that start an automation (manual-trigger, recurrence)
- * - source: Nodes that provide input data (image, video, audio, social-audio, text, account)
- * - generator: Nodes that transform or generate content (image-composer, video-composer, generate-image, llm, compose-workflow)
- * - terminal: Nodes that end an automation (output, auto-post, save-to-media)
- */
-export type NodeCategory = 'trigger' | 'source' | 'generator' | 'terminal';
-export interface NodeControlConfig {
+export interface ComputedNode {
     /** Node type identifier (e.g., 'collect', 'for-each', 'llm') */
     nodeId: string;
     /** Display label for the node */
@@ -142,7 +86,9 @@ export interface NodeControlConfig {
     category: string;
     /** Functional type for node behavior classification */
     type: NodeCategory;
+    /** Pre-computed input ports based on defaults */
     inputs: NodePort[];
+    /** Pre-computed output ports based on defaults */
     outputs: NodePort[];
     /** Available output modes, or null if not applicable */
     outputModes: OutputMode[] | null;
@@ -151,59 +97,14 @@ export interface NodeControlConfig {
     /** Default config values for this node */
     defaults: Record<string, unknown>;
 }
-/**
- * Node definition for the centralized graph controller.
- * Each node type defines its default config and port computation logic.
- */
-export interface NodeDefinition {
-    /** Node type identifier - must match UserCreatableNodeType (e.g., 'collect', 'for-each', 'llm') */
-    nodeId: UserCreatableNodeType;
-    /** Display label for the node */
-    label: string;
-    /** Description shown in add node modal */
-    description: string;
-    /** Functional type for node behavior classification */
-    type: NodeCategory;
-    /** UI display category for grouping in add node modal */
-    category: string;
-    /**
-     * If true, this node supports generating multiple unique outputs per run
-     * when outputMode is 'per-input'. Used for source nodes like media, text.
-     */
-    supportsPerInputMode?: boolean;
-    /**
-     * Returns the default configuration when a node of this type is created.
-     * Should return a valid config that produces valid ports.
-     */
-    getDefaultConfig: () => Record<string, unknown>;
-    /**
-     * Computes the input and output ports for this node based on its config.
-     *
-     * @param config - The node's current configuration
-     * @param getConnectedOutput - Optional callback to get the output port of a connected source node.
-     *                             Used for objectSchema propagation through passthrough nodes.
-     * @returns The computed input and output ports
-     */
-    computePorts: (params: {
-        config: Record<string, unknown>;
-        getConnectedOutput?: (inputId: string) => {
-            type: BasePortType | BasePortType[];
-            isArray: boolean;
-            objectSchema?: ObjectSchemaField[];
-        } | null;
-    }) => {
-        inputs: NodePort[];
-        outputs: NodePort[];
-    };
-}
 export interface OutputSchemaProperty {
     type: 'string' | 'number' | 'boolean' | 'array' | 'object';
     items?: 'string' | 'number' | 'boolean';
     properties?: Record<string, OutputSchemaProperty>;
 }
-export interface WorkflowNodeDefinition {
+/** Base fields shared by all workflow nodes */
+type WorkflowNodeDefinitionBase = {
     id: string;
-    type: NodeTypeEnum;
     name?: string;
     x?: number;
     y?: number;
@@ -211,46 +112,17 @@ export interface WorkflowNodeDefinition {
         sourceNodeId: string;
         sourceOutputId: string;
     }>;
-    config?: {
-        urls?: string[];
-        selectionConfig?: SelectionConfig;
-        selectionState?: SelectionState;
-        outputMode?: OutputMode;
-        outputs?: Array<{
-            id: string;
-            type: string;
-            isArray: boolean;
-            selectedMediaIds: string[];
-        }>;
-        textOptions?: string[];
-        videoEditor?: VideoEditorNodeConfig;
-        imageEditor?: ImageEditorNodeConfig;
-        outputSchema?: Record<string, OutputSchemaProperty>;
-        provider?: 'groq' | 'openai' | 'claude' | 'gemini';
-        model?: string;
-        temperature?: number;
-        maxTokens?: number;
-        useWebSearch?: boolean;
-        useStructuredOutput?: boolean;
-        manualTriggerConfig?: ManualTriggerNodeConfig;
-        recurrenceConfig?: RecurrenceNodeConfig;
-        workflowTemplateId?: string;
-        workflowVariableNameToIdMap?: Record<string, string>;
-        /** Resolved ports from the sub-workflow template (for validation) */
-        resolvedPorts?: ResolvedPorts;
-        outputConfig?: OutputNodeConfig;
-        accountConfig?: AccountNodeConfig;
-        autoPostConfig?: AutoPostNodeConfig;
-        saveToMediaConfig?: SaveToMediaNodeConfig;
-        videoImportConfig?: VideoImportNodeConfig;
-        randomRouteConfig?: RandomRouteNodeConfig;
-        branchConfig?: BranchNodeConfig;
-        autoCaptionConfig?: AutoCaptionNodeConfig;
-        screenshotAnimationConfig?: ScreenshotAnimationConfig;
-        createDmConfig?: CreateDmNodeConfig;
-        collectConfig?: CollectNodeConfig;
+};
+/**
+ * Discriminated union of workflow node definitions.
+ * Each node type has its specific config type, enabling automatic type narrowing.
+ */
+export type WorkflowNodeDefinition = {
+    [K in UserCreatableNodeType]: WorkflowNodeDefinitionBase & {
+        type: K;
+        config: WorkflowConfig[K];
     };
-}
+}[UserCreatableNodeType];
 export interface CanvasState {
     zoom: number;
     panX: number;
@@ -260,14 +132,11 @@ export interface WorkflowDefinition {
     nodes: WorkflowNodeDefinition[];
     canvasState?: CanvasState;
 }
-/**
- * Template node as stored in the database
- */
-export interface TemplateNode {
+/** Base fields shared by all template nodes */
+type TemplateNodeBase = {
     id: string;
     template_id: string;
     node_id: string;
-    type: NodeTypeEnum;
     name: string | null;
     x: number;
     y: number;
@@ -275,7 +144,6 @@ export interface TemplateNode {
         sourceNodeId: string;
         sourceOutputId: string;
     }>;
-    config: WorkflowNodeDefinition['config'] | null;
     cached_output: Record<string, unknown> | null;
     cached_at: string | null;
     cached_run_id: string | null;
@@ -283,7 +151,26 @@ export interface TemplateNode {
     preview_outputs: Record<string, string> | null;
     created_at: string;
     updated_at: string;
-}
+};
+/** User-creatable template nodes have typed config */
+type UserCreatableTemplateNode = {
+    [K in UserCreatableNodeType]: TemplateNodeBase & {
+        type: K;
+        config: WorkflowConfig[K] | null;
+    };
+}[UserCreatableNodeType];
+/** Internal template nodes (created during execution) have no config */
+type InternalTemplateNode = {
+    [K in InternalNodeType]: TemplateNodeBase & {
+        type: K;
+        config: null;
+    };
+}[InternalNodeType];
+/**
+ * Template node as stored in the database.
+ * Discriminated union enabling automatic type narrowing based on node type.
+ */
+export type TemplateNode = UserCreatableTemplateNode | InternalTemplateNode;
 export interface AutomationTemplate {
     id: string;
     org_id: string;
@@ -323,7 +210,7 @@ export interface ExecutorNode {
     id: string;
     template_node_id: string;
     executor_index: number;
-    type: NodeTypeEnum;
+    type: NodeType;
     status: 'pending' | 'running' | 'completed' | 'failed';
     output_value: unknown | null;
     error_message: string | null;

package/dist/automations/types.js

@@ -5,7 +5,7 @@
  * Core types for the automation system including ports, selection, and output modes.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserCreatableNodeTypes = exports.NodeTypes = void 0;
+exports.internalNodeTypes = exports.nodeDefinitions = void 0;
 exports.formatPortType = formatPortType;
 exports.isAsyncExecutor = isAsyncExecutor;
 /**
@@ -18,81 +18,9 @@ function formatPortType(type, isArray) {
     }
     return isArray ? `${type}[]` : type;
 }
-// =============================================================================
-// Node Type Enums
-// =============================================================================
-/**
- * Node types array for runtime use
- */
-exports.NodeTypes = [
-    'social-audio',
-    'text',
-    'media',
-    'video-import',
-    'image-composer',
-    'video-composer',
-    'generate-image',
-    'generate-video',
-    'custom-model',
-    'llm',
-    'passthrough',
-    'manual-trigger',
-    'recurrence',
-    'compose-workflow',
-    'account',
-    'auto-post',
-    'save-to-media',
-    'deduplicate',
-    'for-each',
-    'for-each-value',
-    'transcript',
-    'auto-caption',
-    'screenshot-animation',
-    'random',
-    'random-route',
-    'branch',
-    'if',
-    'not',
-    'create-dm',
-    'collect',
-    'destructure',
-];
-/**
- * User-creatable node types (excludes internal executor types like 'for-each-value')
- * These are the nodes that appear in the node picker and have definitions.
- */
-exports.UserCreatableNodeTypes = [
-    'social-audio',
-    'text',
-    'media',
-    'video-import',
-    'image-composer',
-    'video-composer',
-    'generate-image',
-    'generate-video',
-    'custom-model',
-    'llm',
-    'passthrough',
-    'manual-trigger',
-    'recurrence',
-    'compose-workflow',
-    'account',
-    'auto-post',
-    'save-to-media',
-    'deduplicate',
-    'for-each',
-    'transcript',
-    'auto-caption',
-    'screenshot-animation',
-    'random',
-    'random-route',
-    'branch',
-    'if',
-    'not',
-    'create-dm',
-    'collect',
-    'destructure',
-];
+var nodes_1 = require("./nodes");
+Object.defineProperty(exports, "nodeDefinitions", { enumerable: true, get: function () { return nodes_1.nodeDefinitions; } });
+Object.defineProperty(exports, "internalNodeTypes", { enumerable: true, get: function () { return nodes_1.internalNodeTypes; } });
 /**
  * Type guard to check if an executor is async
  */

package/dist/graph-controller.d.ts

@@ -10,8 +10,9 @@
  *
  * All functions work with WorkflowNodeDefinition[] (embedded connection format).
  */
-import type { WorkflowNodeDefinition, NodeControlConfig, NodePort, BasePortType, ValidationError, UserCreatableNodeType } from './automations/types';
-import type { ObjectSchemaField } from './automations/nodes/types';
+import type { WorkflowNodeDefinition, ComputedNode, NodePort, BasePortType, ValidationError, UserCreatableNodeType } from './automations/types';
+import type { ObjectSchemaField, ResolvedPreview } from './automations/nodes/types';
+import type { AutomationsClient } from './automations';
 /**
  * Connection extracted from embedded inputs format for internal processing
  */
@@ -45,29 +46,31 @@ export declare function areTypesCompatible({ sourceType, sourceIsArray, targetTy
  *
  * @param nodeType - The type of the node
  * @param config - The node's configuration object
+ * @param client - Optional AutomationsClient for nodes that need to fetch data
  * @param getConnectedOutput - Optional function to get connected output port info (for dynamic ports)
  */
-export declare function computePortsForNode({ nodeType, config, getConnectedOutput, }: {
+export declare function computePortsForNode({ nodeType, config, client, getConnectedOutput, }: {
     nodeType: UserCreatableNodeType;
     config?: Record<string, unknown>;
+    client?: AutomationsClient;
     getConnectedOutput?: (inputId: string) => {
         type: BasePortType | BasePortType[];
         isArray: boolean;
         objectSchema?: ObjectSchemaField[];
     } | null;
-}): {
+}): Promise<{
     inputs: NodePort[];
     outputs: NodePort[];
-};
+}>;
 /**
  * Get all available automation nodes.
- * Converts node definitions from the registry into NodeControlConfig format.
+ * Converts node definitions from the registry into ComputedNode format.
  */
-export declare function getAllNodes(): NodeControlConfig[];
+export declare function getAllNodes(client?: AutomationsClient): Promise<ComputedNode[]>;
 /**
  * Get a specific node by nodeId
  */
-export declare function getNodeByType(nodeId: string): NodeControlConfig | undefined;
+export declare function getNodeByType(nodeId: string, client?: AutomationsClient): Promise<ComputedNode | undefined>;
 /**
  * Get the schema of array items for a node's output port.
  * Returns null if schema is unknown or the output is not an array.
@@ -75,13 +78,15 @@ export declare function getNodeByType(nodeId: string): NodeControlConfig | undef
  * @param nodeType - The type of the node (e.g., 'transcript', 'llm')
  * @param nodeConfig - The node's configuration object
  * @param outputPortId - The ID of the output port to get schema for
+ * @param client - Optional AutomationsClient for nodes that need to fetch data
  * @returns The schema of array items, or null if unknown
  */
-export declare function getOutputSchema({ nodeType, nodeConfig, outputPortId, }: {
+export declare function getOutputSchema({ nodeType, nodeConfig, outputPortId, client, }: {
     nodeType: string;
     nodeConfig: Record<string, unknown> | undefined;
     outputPortId: string;
-}): ObjectSchemaField[] | null;
+    client?: AutomationsClient;
+}): Promise<ObjectSchemaField[] | null>;
 /**
  * Derive Connection[] array from nodes for canvas rendering
  *
@@ -162,7 +167,7 @@ export declare function checkCrossContextViolation({ sourceNodeId, targetNodeId,
  */
 export declare function validateWorkflow({ nodes, }: {
     nodes: WorkflowNodeDefinition[];
-}): ValidationError[];
+}): Promise<ValidationError[]>;
 /**
  * Get node IDs that have errors
  */
@@ -191,4 +196,16 @@ export declare function hasMissingTriggerError({ errors }: {
 export declare function hasMissingTerminalError({ errors }: {
     errors: ValidationError[];
 }): boolean;
+/**
+ * Resolve preview data for a node.
+ * Converts node config with refs (inputId/textInputId) to render-ready format.
+ * Delegates to the node definition's resolvePreview function if available.
+ *
+ * @returns ResolvedPreview with render-ready config, sources, and textContent,
+ *          or null if the node doesn't support preview or config is invalid.
+ */
+export declare function resolveNodePreview({ nodes, nodeId, }: {
+    nodes: WorkflowNodeDefinition[];
+    nodeId: string;
+}): ResolvedPreview | null;
 export {};