ugcinc 4.0.2 → 4.1.0

package/dist/automations/nodes/save-to-media.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'save-to-media',
+    label: 'Save To Media',
+    description: 'Save outputs to media library',
+    type: 'terminal',
+    category: 'Output',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        inputs: [{ id: 'input', type: 'image' }],
+        globalTag: undefined,
+        includeDateTag: false,
+        makeUnique: false,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configInputs = (config?.inputs ?? []);
+        const inputs = configInputs.map(input => ({
+            id: input.id,
+            type: input.type,
+            isArray: false,
+            required: true,
+        }));
+        return { inputs, outputs: [] };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/screenshot-animation.d.ts

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

package/dist/automations/nodes/screenshot-animation.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'screenshot-animation',
+    label: 'Animate Screenshot',
+    description: 'Create an iPhone screenshot animation from an image',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        holdDurationMs: 500,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'image',
+                type: 'image',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

package/dist/automations/nodes/social-audio.d.ts

@@ -0,0 +1,8 @@
+declare const definition: import("./types").NodeDefinition<"source", {
+    urls: string[];
+    selectedMediaIds: string[];
+    selectionMode: "random";
+    outputMode: "per-input";
+}>;
+export default definition;
+export type SocialAudioConfig = typeof definition.defaults;

package/dist/automations/nodes/social-audio.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'social-audio',
+    label: 'Social Audio',
+    description: 'Select trending audio for posts',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        urls: [],
+        selectedMediaIds: [],
+        selectionMode: 'random',
+        outputMode: 'per-input',
+    },
+    computePorts: () => ({
+        inputs: [],
+        outputs: [
+            {
+                id: 'social-audio',
+                type: 'social_audio',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

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

@@ -0,0 +1,7 @@
+declare const definition: import("./types").NodeDefinition<"source", {
+    textOptions: string[];
+    selectionMode: "random";
+    outputMode: "per-input";
+}>;
+export default definition;
+export type TextConfig = typeof definition.defaults;

package/dist/automations/nodes/text.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const internal_utils_1 = require("../../internal-utils");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'text',
+    label: 'Text',
+    description: 'Use text collections',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        textOptions: [],
+        selectionMode: 'random',
+        outputMode: 'per-input',
+    },
+    computePorts: ({ config }) => {
+        const textOptions = (config?.textOptions ?? []);
+        const variables = (0, internal_utils_1.extractTemplateVariables)(textOptions);
+        // Generate inputs from template variables
+        const inputs = variables.map(variable => ({
+            id: variable,
+            type: 'text',
+            isArray: false,
+            required: false,
+        }));
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'text',
+                    type: 'text',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

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

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

package/dist/automations/nodes/transcript.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'transcript',
+    label: 'Transcribe',
+    description: 'Transcribe video or audio with timestamps',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'media',
+                type: ['video', 'audio'],
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'text',
+                type: 'text',
+                isArray: false,
+                required: true,
+            },
+            {
+                id: 'segments',
+                type: 'object',
+                isArray: false,
+                required: true,
+                objectSchema: [
+                    { name: 'text', type: 'string' },
+                    { name: 'start', type: 'number' },
+                    { name: 'end', type: 'number' },
+                ],
+            },
+        ],
+    }),
+});
+exports.default = definition;

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

@@ -0,0 +1,178 @@
+/**
+ * Node Definition Types
+ *
+ * This file contains shared types for node definitions.
+ * Each node file imports from here and defines its behavior.
+ */
+import type { NodePort, BasePortType } from '../types';
+export type NodeCategory = 'trigger' | 'source' | 'generator' | 'terminal';
+export type OutputMode = 'per-input' | 'single';
+export type SelectionMode = 'random' | 'sequential';
+export type ExhaustionBehavior = 'restart' | 'error';
+export type InputType = 'static' | 'variable';
+type PrimitiveType = 'string' | 'number' | 'boolean';
+/**
+ * Generic type for object schema fields with compile-time depth enforcement.
+ *
+ * - Level 1 (default): Can have 'object' or 'array' types, arrays can contain objects
+ * - Level 2: Can have 'object' or 'array' types, arrays cannot contain objects
+ * - Level 3: Only primitive types allowed
+ *
+ * @example
+ * // Level 1 field (top-level)
+ * const field: SchemaField = { name: 'users', type: 'array', items: 'object', objectSchema: [...] };
+ *
+ * // Level 2 field (inside objectSchema)
+ * const nested: SchemaField<true, false> = { name: 'tags', type: 'array', items: 'string' };
+ *
+ * // Level 3 field (deepest level)
+ * const leaf: SchemaField<false, false> = { name: 'id', type: 'string' };
+ */
+/**
+ * Schema field type with compile-time depth enforcement for array items.
+ *
+ * - Level 1 (default): Arrays can contain objects (`items: 'object'`)
+ * - Level 2+: Arrays can only contain primitives
+ *
+ * The `objectSchema` property is always `ObjectSchemaField[]` so it can be
+ * passed directly to ports without type mismatches.
+ */
+export type SchemaField<CanNestObjects extends boolean = true> = {
+    name: string;
+    description?: string;
+    type: PrimitiveType | 'object' | 'array';
+    items?: PrimitiveType | (CanNestObjects extends true ? 'object' : never);
+    objectSchema?: ObjectSchemaField[];
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    required?: boolean;
+};
+/** Top-level schema field - arrays can contain objects */
+export type ObjectSchemaField = SchemaField<true>;
+/** Nested schema field (inside objectSchema) - arrays can only contain primitives */
+export type NestedSchemaField = SchemaField<false>;
+export interface BranchValueConfig {
+    inputType?: InputType;
+}
+export interface PassthroughInput {
+    id: string;
+    type: string;
+    isArray?: boolean;
+    branchValues?: Record<string, BranchValueConfig>;
+}
+export interface SelectionConfig {
+    mode?: SelectionMode;
+    enforceUniqueness?: boolean;
+    exhaustionBehavior?: ExhaustionBehavior;
+}
+export interface SelectionState {
+    usedIndices: number[];
+    currentIndex: number;
+}
+/**
+ * Iteration mode for trigger nodes with account iteration
+ * - 'fan-out': Spawn all runs simultaneously (one per account)
+ * - 'sequential': One account per trigger fire, cycling through the collection
+ */
+export type TriggerIterationMode = 'fan-out' | 'sequential';
+/**
+ * Behavior when sequential iteration exhausts all accounts
+ * - 'repeat': Start from the beginning of the collection
+ * - 'stop': Stop the automation (disable schedule for recurrence)
+ */
+export type IterationExhaustionBehavior = 'repeat' | 'stop';
+/**
+ * Selection mode for collection inputs
+ * - 'specific': Use hardcoded IDs configured at design time
+ * - 'by-tag': Query items by tag at runtime (allows dynamic collections)
+ */
+export type CollectionSelectionMode = 'specific' | 'by-tag';
+/**
+ * Account iteration configuration for trigger nodes
+ * When enabled, the trigger iterates over a collection of accounts
+ */
+export interface TriggerCollectionConfig {
+    /** Whether account iteration is enabled */
+    enabled: boolean;
+    /** Selection mode: 'specific' uses accountIds, 'by-tag' queries at runtime */
+    selectionMode?: CollectionSelectionMode;
+    /** Account IDs to iterate over (used when selectionMode is 'specific' or undefined) */
+    accountIds?: string[];
+    /** Tag to query accounts by at runtime (used when selectionMode is 'by-tag') */
+    accountTag?: string;
+}
+/**
+ * Computes the required outputMode/selectionMode types based on node category.
+ * - trigger/terminal: both null
+ * - generator: outputMode required, selectionMode null
+ * - source: both required
+ */
+type DefaultsForCategory<T extends NodeCategory, TCustom extends Record<string, unknown>> = T extends 'source' ? TCustom & {
+    outputMode: OutputMode;
+    selectionMode: SelectionMode;
+} : T extends 'generator' ? TCustom & {
+    outputMode: OutputMode;
+    selectionMode: null;
+} : TCustom & {
+    outputMode: null;
+    selectionMode: null;
+};
+/**
+ * Computes the outputModes array type based on node category.
+ */
+type OutputModesForCategory<T extends NodeCategory> = T extends 'source' | 'generator' ? OutputMode[] : null;
+/**
+ * Computes the selectionModes array type based on node category.
+ */
+type SelectionModesForCategory<T extends NodeCategory> = T extends 'source' ? SelectionMode[] : null;
+export interface NodeDefinition<T extends NodeCategory = NodeCategory, TDefaults extends Record<string, unknown> = Record<string, unknown>> {
+    nodeId: string;
+    label: string;
+    description: string;
+    type: T;
+    category: string;
+    outputModes: OutputModesForCategory<T>;
+    selectionModes: SelectionModesForCategory<T>;
+    defaults: DefaultsForCategory<T, TDefaults>;
+    computePorts: (params: {
+        config: DefaultsForCategory<T, TDefaults>;
+        getConnectedOutput?: (inputId: string) => {
+            type: BasePortType | BasePortType[];
+            isArray: boolean;
+            objectSchema?: ObjectSchemaField[];
+        } | null;
+    }) => {
+        inputs: NodePort[];
+        outputs: NodePort[];
+    };
+}
+/**
+ * Define a node with full type inference.
+ *
+ * - outputMode/selectionMode in defaults are typed based on the node's `type`
+ * - Custom defaults are merged and available in computePorts
+ * - No manual type assertions needed
+ */
+export declare function defineNode<T extends NodeCategory, TCustomDefaults extends Record<string, unknown>>(def: {
+    nodeId: string;
+    label: string;
+    description: string;
+    type: T;
+    category: string;
+    outputModes: OutputModesForCategory<T>;
+    selectionModes: SelectionModesForCategory<T>;
+    defaults: DefaultsForCategory<T, TCustomDefaults>;
+    computePorts: (params: {
+        config: DefaultsForCategory<T, TCustomDefaults>;
+        getConnectedOutput?: (inputId: string) => {
+            type: BasePortType | BasePortType[];
+            isArray: boolean;
+            objectSchema?: ObjectSchemaField[];
+        } | null;
+    }) => {
+        inputs: NodePort[];
+        outputs: NodePort[];
+    };
+}): NodeDefinition<T, TCustomDefaults>;
+export {};

package/dist/automations/nodes/types.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Node Definition Types
+ *
+ * This file contains shared types for node definitions.
+ * Each node file imports from here and defines its behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineNode = defineNode;
+// =============================================================================
+// Helper Function
+// =============================================================================
+/**
+ * Define a node with full type inference.
+ *
+ * - outputMode/selectionMode in defaults are typed based on the node's `type`
+ * - Custom defaults are merged and available in computePorts
+ * - No manual type assertions needed
+ */
+function defineNode(def) {
+    return def;
+}

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

@@ -0,0 +1,25 @@
+import type { VideoEditorNodeConfig } from '../../render/types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    videoEditor: {
+        width: number;
+        height: number;
+        fps: number;
+        dimensionPreset: string;
+        channels: {
+            id: string;
+            name: string;
+            segments: never[];
+        }[];
+    };
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type VideoComposerConfig = typeof definition.defaults;
+/**
+ * Input to the video-composer node executor
+ */
+export interface VideoEditorNodeInput extends Record<string, unknown> {
+    type: 'video-composer';
+    editor: VideoEditorNodeConfig;
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'video-composer',
+    label: 'Video Composer',
+    description: 'Create templated videos',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        videoEditor: {
+            width: 1080,
+            height: 1920,
+            fps: 30,
+            dimensionPreset: '9:16',
+            channels: [{
+                    id: 'main-track',
+                    name: 'Main Track',
+                    segments: [],
+                }],
+        },
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const editorConfig = config?.videoEditor;
+        const inputs = [];
+        const addedIds = new Set();
+        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,
+                        });
+                    }
+                    if (segment.textInputRef && !addedIds.has(segment.textInputRef)) {
+                        addedIds.add(segment.textInputRef);
+                        inputs.push({
+                            id: segment.textInputRef,
+                            type: 'text',
+                            isArray: false,
+                            required: segment.required ?? true,
+                        });
+                    }
+                });
+            });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'video',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,27 @@
+/**
+ * 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";
+}>;
+export default definition;
+export type VideoImportConfig = typeof definition.defaults;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'video-import',
+    label: 'Import Video',
+    description: 'Import videos from YouTube, TikTok, Instagram & more',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        platform: 'youtube',
+        videoQuality: '1080',
+        outputMode: 'per-input',
+        selectionMode: 'random',
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'url',
+                type: 'text',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'video',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;