ugcinc 4.0.2 → 4.1.0

package/dist/nodes/image-composer.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'image-composer',
+    label: 'Image Composer',
+    description: 'Create templated images',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        imageEditor: {
+            width: 1080,
+            height: 1920,
+            aspectRatio: '9:16',
+            dimensionPreset: '9:16',
+            backgroundType: 'image',
+            elements: [],
+        },
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const editorConfig = config?.imageEditor;
+        const inputs = [];
+        if (editorConfig) {
+            // Add background input if backgroundType is not 'color'
+            if (editorConfig.backgroundType !== 'color') {
+                inputs.push({
+                    id: 'background',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                });
+            }
+            // Add inputs for each element with inputId or textInputId
+            editorConfig.elements.forEach(elem => {
+                if (elem.type === 'image' && elem.inputId) {
+                    inputs.push({
+                        id: elem.inputId,
+                        type: 'image',
+                        isArray: false,
+                        required: true,
+                    });
+                }
+                else if (elem.type === 'text' && elem.textInputId) {
+                    inputs.push({
+                        id: elem.textInputId,
+                        type: 'text',
+                        isArray: false,
+                        required: true,
+                    });
+                }
+            });
+            // Build enum options from element IDs for crop boundary inputs
+            const elementEnumOptions = editorConfig.elements.map(elem => ({
+                label: elem.id,
+                value: elem.id,
+            }));
+            // Add crop boundary inputs as enum type (not required)
+            const addedCropInputs = new Set();
+            const cropConfig = editorConfig.dynamicCrop;
+            [
+                cropConfig?.vertical?.startBoundary?.inputRef,
+                cropConfig?.vertical?.endBoundary?.inputRef,
+                cropConfig?.horizontal?.startBoundary?.inputRef,
+                cropConfig?.horizontal?.endBoundary?.inputRef,
+            ].forEach(inputRef => {
+                if (inputRef && !addedCropInputs.has(inputRef)) {
+                    addedCropInputs.add(inputRef);
+                    inputs.push({
+                        id: inputRef,
+                        type: 'enum',
+                        isArray: false,
+                        required: false,
+                        enumOptions: elementEnumOptions,
+                    });
+                }
+            });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/nodes/index.d.ts

@@ -0,0 +1,20 @@
+import type { UserCreatableNodeType } from '../types';
+import type { NodeDefinition } from './types';
+type AnyNodeDefinition = NodeDefinition<any, any>;
+/**
+ * Registry of all user-creatable node definitions.
+ * This is the single source of truth for node types.
+ *
+ * Note: Internal executor types like 'for-each-value' are not included here
+ * as they are created dynamically during execution, not by users.
+ */
+export declare const nodeDefinitions: Record<UserCreatableNodeType, AnyNodeDefinition>;
+/**
+ * Get all node definitions as an array
+ */
+export declare function getAllNodeDefinitions(): AnyNodeDefinition[];
+/**
+ * Get a node definition by its nodeId
+ */
+export declare function getNodeDefinition(nodeId: UserCreatableNodeType): AnyNodeDefinition | undefined;
+export {};

package/dist/nodes/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeDefinitions = void 0;
+exports.getAllNodeDefinitions = getAllNodeDefinitions;
+exports.getNodeDefinition = getNodeDefinition;
+// Import all node definitions
+const account_1 = __importDefault(require("./account"));
+const auto_caption_1 = __importDefault(require("./auto-caption"));
+const auto_post_1 = __importDefault(require("./auto-post"));
+const branch_1 = __importDefault(require("./branch"));
+const collect_1 = __importDefault(require("./collect"));
+const compose_workflow_1 = __importDefault(require("./compose-workflow"));
+const create_dm_1 = __importDefault(require("./create-dm"));
+const custom_model_1 = __importDefault(require("./custom-model"));
+const deduplicate_1 = __importDefault(require("./deduplicate"));
+const destructure_1 = __importDefault(require("./destructure"));
+const for_each_1 = __importDefault(require("./for-each"));
+const generate_image_1 = __importDefault(require("./generate-image"));
+const generate_video_1 = __importDefault(require("./generate-video"));
+const if_1 = __importDefault(require("./if"));
+const image_composer_1 = __importDefault(require("./image-composer"));
+const llm_1 = __importDefault(require("./llm"));
+const manual_trigger_1 = __importDefault(require("./manual-trigger"));
+const media_1 = __importDefault(require("./media"));
+const not_1 = __importDefault(require("./not"));
+const output_1 = __importDefault(require("./output"));
+const random_1 = __importDefault(require("./random"));
+const random_route_1 = __importDefault(require("./random-route"));
+const recurrence_1 = __importDefault(require("./recurrence"));
+const save_to_media_1 = __importDefault(require("./save-to-media"));
+const screenshot_animation_1 = __importDefault(require("./screenshot-animation"));
+const social_audio_1 = __importDefault(require("./social-audio"));
+const text_1 = __importDefault(require("./text"));
+const transcript_1 = __importDefault(require("./transcript"));
+const video_composer_1 = __importDefault(require("./video-composer"));
+const video_import_1 = __importDefault(require("./video-import"));
+/**
+ * Registry of all user-creatable node definitions.
+ * This is the single source of truth for node types.
+ *
+ * Note: Internal executor types like 'for-each-value' are not included here
+ * as they are created dynamically during execution, not by users.
+ */
+exports.nodeDefinitions = {
+    'account': account_1.default,
+    'auto-caption': auto_caption_1.default,
+    'auto-post': auto_post_1.default,
+    'branch': branch_1.default,
+    'collect': collect_1.default,
+    'compose-workflow': compose_workflow_1.default,
+    'create-dm': create_dm_1.default,
+    'custom-model': custom_model_1.default,
+    'deduplicate': deduplicate_1.default,
+    'destructure': destructure_1.default,
+    'for-each': for_each_1.default,
+    'generate-image': generate_image_1.default,
+    'generate-video': generate_video_1.default,
+    'if': if_1.default,
+    'image-composer': image_composer_1.default,
+    'llm': llm_1.default,
+    'manual-trigger': manual_trigger_1.default,
+    'media': media_1.default,
+    'not': not_1.default,
+    'output': output_1.default,
+    'random': random_1.default,
+    'random-route': random_route_1.default,
+    'recurrence': recurrence_1.default,
+    'save-to-media': save_to_media_1.default,
+    'screenshot-animation': screenshot_animation_1.default,
+    'social-audio': social_audio_1.default,
+    'text': text_1.default,
+    'transcript': transcript_1.default,
+    'video-composer': video_composer_1.default,
+    'video-import': video_import_1.default,
+};
+// =============================================================================
+// Getters
+// =============================================================================
+/**
+ * Get all node definitions as an array
+ */
+function getAllNodeDefinitions() {
+    return Object.values(exports.nodeDefinitions);
+}
+/**
+ * Get a node definition by its nodeId
+ */
+function getNodeDefinition(nodeId) {
+    return exports.nodeDefinitions[nodeId];
+}

package/dist/nodes/llm.d.ts

@@ -0,0 +1,27 @@
+import { type ObjectSchemaField } from './types';
+declare const LLMProviders: readonly ["groq", "openai", "claude", "gemini"];
+type LLMProvider = typeof LLMProviders[number];
+interface LLMApiKeys {
+    openai?: string;
+    claude?: string;
+    gemini?: string;
+    groq?: string;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    provider: LLMProvider;
+    model: string;
+    temperature: number;
+    maxTokens: number | undefined;
+    systemPrompt: string;
+    outputFields: ObjectSchemaField[];
+    useStructuredOutput: boolean;
+    imageInputRefs: string[];
+    videoInputRefs: string[];
+    apiKeys: LLMApiKeys | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { LLMProviders };
+export type { LLMProvider, LLMApiKeys };
+export type LLMConfig = typeof definition.defaults;

package/dist/nodes/llm.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMProviders = void 0;
+const internal_utils_1 = require("../internal-utils");
+const types_1 = require("./types");
+const LLMProviders = ['groq', 'openai', 'claude', 'gemini'];
+exports.LLMProviders = LLMProviders;
+const definition = (0, types_1.defineNode)({
+    nodeId: 'llm',
+    label: 'LLM',
+    description: 'Generate LLM output',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        provider: 'claude',
+        model: 'claude-sonnet-4-5',
+        temperature: 0.7,
+        maxTokens: undefined,
+        systemPrompt: '',
+        outputFields: [{ name: 'output', type: 'string' }],
+        useStructuredOutput: true,
+        imageInputRefs: [],
+        videoInputRefs: [],
+        apiKeys: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        // Input ports from template variables + media refs
+        const systemPrompt = config?.systemPrompt ?? '';
+        const variables = (0, internal_utils_1.extractTemplateVariables)([systemPrompt]);
+        const imageInputRefs = config?.imageInputRefs ?? [];
+        const videoInputRefs = config?.videoInputRefs ?? [];
+        const inputs = [
+            ...variables.map(v => ({
+                id: v,
+                type: ['text', 'object', 'boolean'],
+                isArray: false,
+                required: true,
+            })),
+            ...imageInputRefs.map(ref => ({
+                id: ref,
+                type: 'image',
+                isArray: false,
+                required: true,
+            })),
+            ...videoInputRefs.map(ref => ({
+                id: ref,
+                type: 'video',
+                isArray: false,
+                required: true,
+            })),
+        ];
+        // Output ports from outputFields
+        const outputFields = (config?.outputFields ?? [{ name: 'output', type: 'string' }]);
+        const outputs = outputFields.map(f => {
+            let pType;
+            let pIsArray;
+            if (f.type === 'array') {
+                pType = f.items === 'object' ? 'object' : 'text';
+                pIsArray = true;
+            }
+            else if (f.type === 'object') {
+                pType = 'object';
+                pIsArray = false;
+            }
+            else {
+                pType = 'text';
+                pIsArray = false;
+            }
+            return {
+                id: f.name,
+                type: pType,
+                isArray: pIsArray,
+                required: f.required ?? true,
+                // Include objectSchema for object/array-of-object types
+                ...(f.objectSchema && { objectSchema: f.objectSchema }),
+            };
+        });
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/nodes/manual-trigger.d.ts

@@ -0,0 +1,16 @@
+import type { EnumOption } from '../types';
+import { type ObjectSchemaField } from './types';
+interface ManualTriggerOutput {
+    id: string;
+    type: string;
+    isArray?: boolean;
+    objectSchema?: ObjectSchemaField[];
+    enumOptions?: EnumOption[];
+}
+declare const definition: import("./types").NodeDefinition<"trigger", {
+    outputs: ManualTriggerOutput[];
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type ManualTriggerConfig = typeof definition.defaults;

package/dist/nodes/manual-trigger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'manual-trigger',
+    label: 'Manual Trigger',
+    description: 'Trigger manually',
+    type: 'trigger',
+    category: 'Triggers',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        outputs: [{ id: 'input-1', type: 'image' }],
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configOutputs = config?.outputs ?? [];
+        const outputs = configOutputs.map(output => ({
+            id: output.id,
+            type: output.type,
+            isArray: output.isArray ?? false,
+            required: true,
+            ...(output.type === 'enum' && output.enumOptions ? { enumOptions: output.enumOptions } : {}),
+        }));
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

package/dist/nodes/media.d.ts

@@ -0,0 +1,17 @@
+import { type SelectionConfig } from './types';
+type MediaNodeEnabledType = 'image' | 'video' | 'audio';
+declare const definition: import("./types").NodeDefinition<"source", {
+    outputs: {
+        id: string;
+        type: MediaNodeEnabledType;
+        isArray: boolean;
+        selectedMediaIds: string[];
+        selectionConfig: SelectionConfig | undefined;
+    }[];
+    outputMode: "per-input";
+    selectionMode: "random";
+}>;
+export default definition;
+export type { MediaNodeEnabledType };
+export type MediaConfig = typeof definition.defaults;
+export type MediaNodeOutput = MediaConfig['outputs'][number];

package/dist/nodes/media.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'media',
+    label: 'Media',
+    description: 'Use saved media',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        outputs: [{
+                id: 'image-1',
+                type: 'image',
+                isArray: false,
+                selectedMediaIds: [],
+                selectionConfig: undefined,
+            }],
+        outputMode: 'per-input',
+        selectionMode: 'random',
+    },
+    computePorts: ({ config }) => {
+        const outputConfigs = config?.outputs ?? [];
+        // Generate output ports from config (only those with selected media)
+        const outputs = outputConfigs
+            .filter(o => o.selectedMediaIds.length > 0)
+            .map(o => ({
+            id: o.id,
+            type: o.type,
+            isArray: o.isArray,
+            required: true,
+        }));
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

package/dist/nodes/not.d.ts

@@ -0,0 +1,6 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type NotConfig = typeof definition.defaults;

package/dist/nodes/not.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'not',
+    label: 'Not',
+    description: 'Invert a boolean value',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'input',
+                type: 'boolean',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'boolean',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

package/dist/nodes/output.d.ts

@@ -0,0 +1,9 @@
+import type { OutputInput } from '../types';
+declare const definition: import("./types").NodeDefinition<"terminal", {
+    inputs: OutputInput[];
+    mainPreviewInputId: string | undefined;
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type PassthroughConfig = typeof definition.defaults;

package/dist/nodes/output.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'passthrough',
+    label: 'Pass-Through',
+    description: 'Pass data to parent workflow',
+    type: 'terminal',
+    category: 'Output',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        inputs: [{ id: 'result', type: 'image' }],
+        mainPreviewInputId: undefined,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configInputs = config?.inputs ?? [];
+        const inputs = configInputs.map(input => ({
+            id: input.id,
+            type: input.type,
+            isArray: input.isArray ?? false,
+            required: false,
+        }));
+        return {
+            inputs,
+            outputs: [],
+        };
+    },
+});
+exports.default = definition;

package/dist/nodes/random-route.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/random-route.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'random-route',
+    label: 'Random Branch',
+    description: 'Route inputs to a randomly selected branch',
+    type: 'generator',
+    category: 'Control Flow',
+    getDefaultConfig: () => ({
+        randomRouteConfig: {
+            branches: [
+                { id: 'branch-1', probability: 50 },
+                { id: 'branch-2', probability: 50 },
+            ],
+            passthroughInputs: [{ id: 'input', type: 'image', isArray: false, isVariable: false }],
+        },
+        outputMode: 'single',
+    }),
+    computePorts: ({ config }) => {
+        const routeConfig = config?.randomRouteConfig;
+        const branches = routeConfig?.branches ?? [];
+        const passthroughInputs = routeConfig?.passthroughInputs ?? [];
+        const inputs = [];
+        const outputs = [];
+        // Input ports: only passthroughs where isVariable is true
+        for (const passthrough of passthroughInputs) {
+            if (passthrough.isVariable) {
+                inputs.push({
+                    id: passthrough.id,
+                    type: passthrough.type,
+                    isArray: passthrough.isArray ?? false,
+                    required: true,
+                });
+            }
+        }
+        // Output ports: {branch.id}-{passthrough.id} for each combination
+        for (const branch of branches) {
+            for (const passthrough of passthroughInputs) {
+                outputs.push({
+                    id: `${branch.id}-${passthrough.id}`,
+                    type: passthrough.type,
+                    isArray: passthrough.isArray ?? false,
+                    required: true,
+                });
+            }
+        }
+        return { inputs, outputs };
+    },
+};
+exports.default = definition;

package/dist/nodes/random.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/random.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'random',
+    label: 'Random Select',
+    description: 'Randomly select from an array or weighted inputs',
+    type: 'generator',
+    category: 'Control Flow',
+    getDefaultConfig: () => ({
+        randomConfig: {
+            mode: 'array',
+            valueType: 'object',
+            exposeIndex: false,
+        },
+        outputMode: 'single',
+    }),
+    computePorts: ({ config }) => {
+        const randomConfig = config?.randomConfig;
+        const mode = randomConfig?.mode ?? 'array';
+        const valueType = (randomConfig?.valueType ?? 'object');
+        const exposeIndex = randomConfig?.exposeIndex ?? false;
+        const inputPorts = randomConfig?.inputPorts ?? [];
+        const inputs = [];
+        const outputs = [];
+        if (mode === 'array') {
+            inputs.push({ id: 'array', type: 'object', isArray: false, required: true });
+        }
+        else {
+            // Multi-input mode: only add ports where isVariable is true
+            for (const port of inputPorts) {
+                if (port.isVariable) {
+                    inputs.push({
+                        id: port.id,
+                        type: valueType,
+                        isArray: false,
+                        required: true,
+                    });
+                }
+            }
+        }
+        outputs.push({ id: 'output', type: valueType, isArray: false, required: true });
+        if (mode === 'array' && exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', isArray: false, required: true });
+        }
+        return { inputs, outputs };
+    },
+};
+exports.default = definition;

package/dist/nodes/recurrence.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;