ugcinc 4.1.30 → 4.1.32

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

@@ -1,8 +1,19 @@
+import type { AccountData } from '../types';
 import { type SelectionMode, type OutputMode } from './types';
+/** Account node has no inputs (source node) */
+export interface AccountNodeInputs {
+}
+export interface AccountNodeOutputs {
+    account: AccountData;
+}
 declare const definition: import("./types").NodeDefinition<"source", {
     accountIds: string[];
     outputMode: OutputMode;
     selectionMode: SelectionMode;
-}, false>;
-export default definition;
+}, AccountNodeInputs, AccountNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: AccountNodeInputs;
+    __TOutputs: AccountNodeOutputs;
+};
+export default _default;
 export type AccountNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/account.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+const selection_1 = require("../selection");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'account',
     label: 'Account',
@@ -25,5 +29,16 @@ const definition = (0, types_1.defineNode)({
             },
         ],
     }),
+    generatePreview: (config, ctx) => {
+        const pool = config.accountIds;
+        if (pool.length === 0)
+            return (0, types_1.preview)({ account: null });
+        // For single mode, always return first; for per-input, use selection
+        const index = config.outputMode === 'single' ? 0 : ctx.selectionState.consumedCount;
+        const selectedId = (0, selection_1.selectFromPool)(pool, config.selectionMode, index, 'preview');
+        // Look up full AccountData from context
+        const account = selectedId ? ctx.accounts.find(a => a.id === selectedId) ?? null : null;
+        return (0, types_1.preview)({ account });
+    },
 });
 exports.default = definition;

package/dist/automations/nodes/auto-caption.d.ts

@@ -1,3 +1,11 @@
+import type { VideoValue } from '../types';
+import { type OutputMode } from './types';
+export interface AutoCaptionNodeInputs {
+    video: VideoValue;
+}
+export interface AutoCaptionNodeOutputs {
+    output: VideoValue;
+}
 export type AutoCaptionPreset = 'hormozi' | 'minimal' | 'bold-pop' | 'clean' | 'neon';
 export type AutoCaptionFontWeight = 'normal' | 'bold' | 'black';
 export type AutoCaptionPosition = 'top' | 'center' | 'bottom';
@@ -17,8 +25,12 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     wordsPerSubtitle: number | undefined;
     enableAnimation: boolean | undefined;
     language: string | undefined;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, AutoCaptionNodeInputs, AutoCaptionNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: AutoCaptionNodeInputs;
+    __TOutputs: AutoCaptionNodeOutputs;
+};
+export default _default;
 export type AutoCaptionNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/auto-caption.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'auto-caption',
     label: 'Auto Caption',
@@ -46,5 +49,9 @@ const definition = (0, types_1.defineNode)({
             },
         ],
     }),
+    generatePreview: (_config, _ctx, cachedOutputs) => {
+        // Generator node - return cached output from last successful run
+        return (0, types_1.preview)({ output: cachedOutputs?.output ?? null });
+    },
 });
 exports.default = definition;

package/dist/automations/nodes/auto-post.d.ts

@@ -1,4 +1,10 @@
+import type { PortValue } from '../types';
 import { type InputType } from './types';
+/** Auto post inputs are dynamic (video or images + account + optional fields). */
+export type AutoPostNodeInputs = Record<string, PortValue | PortValue[]>;
+/** Auto post has no outputs (terminal node). */
+export interface AutoPostNodeOutputs {
+}
 export type AutoPostMode = 'video' | 'slideshow';
 export type PostSchedulingMode = 'scheduled' | 'queue';
 declare const definition: import("./types").NodeDefinition<"terminal", {
@@ -18,6 +24,10 @@ declare const definition: import("./types").NodeDefinition<"terminal", {
     requireApproval: boolean;
     outputMode: null;
     selectionMode: null;
-}, false>;
-export default definition;
+}, AutoPostNodeInputs, AutoPostNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: AutoPostNodeInputs;
+    __TOutputs: AutoPostNodeOutputs;
+};
+export default _default;
 export type AutoPostNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/auto-post.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'auto-post',
     label: 'Auto Post',
@@ -49,5 +52,9 @@ const definition = (0, types_1.defineNode)({
         }
         return { inputs, outputs: [] };
     },
+    generatePreview: (_config, _ctx) => {
+        // Terminal node - no outputs
+        return (0, types_1.preview)({});
+    },
 });
 exports.default = definition;

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

@@ -1,4 +1,14 @@
-import { type ObjectSchemaField, type InputType } from './types';
+import type { PortValue } from '../types';
+import { type ObjectSchemaField, type InputType, type OutputMode } from './types';
+/**
+ * Branch node inputs: required key input + dynamic branch-specific inputs.
+ * Input port IDs are user-defined (except 'key').
+ */
+export type BranchNodeInputs = Record<string, PortValue | PortValue[]>;
+/**
+ * Branch node outputs: passthrough outputs with user-defined IDs.
+ */
+export type BranchNodeOutputs = Record<string, PortValue | PortValue[]>;
 export interface BranchDefinition {
     key: string;
 }
@@ -14,14 +24,16 @@ export interface BranchPassthroughInput {
     branchValues?: Record<string, BranchValueConfig>;
     objectSchema?: ObjectSchemaField[];
 }
-/** @deprecated Use BranchPassthroughInput instead */
-export type PassthroughInput = BranchPassthroughInput;
 declare const definition: import("./types").NodeDefinition<"generator", {
     branches: BranchDefinition[];
     passthroughInputs: BranchPassthroughInput[];
     defaultBranchKey: string;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, BranchNodeInputs, BranchNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: BranchNodeInputs;
+    __TOutputs: BranchNodeOutputs;
+};
+export default _default;
 export type BranchNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/branch.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'branch',
     label: 'Branch',
@@ -64,5 +67,28 @@ const definition = (0, types_1.defineNode)({
         }
         return { inputs, outputs };
     },
+    generatePreview: (config, ctx) => {
+        const result = {};
+        // For routing nodes, show preview for all passthrough outputs
+        // Each output gets the preview from its corresponding variable input (if any)
+        // or falls back to showing the first available branch value
+        for (const passthrough of config.passthroughInputs) {
+            // Check each branch for a variable input
+            let previewValue = null;
+            for (const branch of config.branches) {
+                const branchValue = passthrough.branchValues?.[branch.key];
+                if (branchValue?.inputType === 'variable') {
+                    const inputPortId = `${branch.key}-${passthrough.id}`;
+                    const inputPreview = ctx.inputPreviews[inputPortId];
+                    if (inputPreview) {
+                        previewValue = inputPreview;
+                        break; // Use first available
+                    }
+                }
+            }
+            result[passthrough.id] = previewValue;
+        }
+        return (0, types_1.preview)(result);
+    },
 });
 exports.default = definition;

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

@@ -1,8 +1,22 @@
+import type { ImageValue, VideoValue, AudioValue, TextValue, ObjectValue, BooleanValue, NumberValue } from '../types';
+import { type OutputMode } from './types';
+/** Value type union for collect node (accepts any of these types) */
+export type CollectInputValue = ImageValue | VideoValue | AudioValue | TextValue | ObjectValue | BooleanValue | NumberValue;
+export interface CollectNodeInputs {
+    value: CollectInputValue;
+}
+export interface CollectNodeOutputs {
+    array: CollectInputValue[];
+}
 declare const definition: import("./types").NodeDefinition<"generator", {
     expectedCount: number | undefined;
     forEachTemplateId: string | undefined;
-    outputMode: "single";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, CollectNodeInputs, CollectNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: CollectNodeInputs;
+    __TOutputs: CollectNodeOutputs;
+};
+export default _default;
 export type CollectNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/collect.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'collect',
     label: 'Collect',
@@ -48,5 +51,10 @@ const definition = (0, types_1.defineNode)({
         ];
         return { inputs, outputs };
     },
+    generatePreview: (_config, _ctx, cachedOutputs) => {
+        return (0, types_1.preview)({
+            array: cachedOutputs?.array ?? null,
+        });
+    },
 });
 exports.default = definition;

package/dist/automations/nodes/compose-workflow.d.ts

@@ -1,11 +1,20 @@
-import type { ResolvedPorts } from '../types';
+import type { ResolvedPorts, PortValue } from '../types';
+import { type OutputMode } from './types';
+/** Compose workflow inputs are fully dynamic (from resolvedPorts). */
+export type ComposeWorkflowNodeInputs = Record<string, PortValue | PortValue[]>;
+/** Compose workflow outputs are fully dynamic (from resolvedPorts). */
+export type ComposeWorkflowNodeOutputs = Record<string, PortValue | PortValue[]>;
 declare const definition: import("./types").NodeDefinition<"generator", {
     workflowTemplateId: string | undefined;
     workflowName: string | undefined;
     workflowPreviewOutput: string | undefined;
     resolvedPorts: ResolvedPorts | undefined;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, ComposeWorkflowNodeInputs, ComposeWorkflowNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: ComposeWorkflowNodeInputs;
+    __TOutputs: ComposeWorkflowNodeOutputs;
+};
+export default _default;
 export type ComposeWorkflowNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/compose-workflow.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'compose-workflow',
     label: 'Compose Workflow',
@@ -28,5 +31,13 @@ const definition = (0, types_1.defineNode)({
         // No cached ports yet - UI will fetch and update
         return { inputs: [], outputs: [] };
     },
+    generatePreview: (config, _ctx, cachedOutputs) => {
+        const result = {};
+        const outputs = config.resolvedPorts?.outputs ?? [];
+        for (const output of outputs) {
+            result[output.id] = cachedOutputs?.[output.id] ?? null;
+        }
+        return (0, types_1.preview)(result);
+    },
 });
 exports.default = definition;

package/dist/automations/nodes/create-dm.d.ts

@@ -1,4 +1,11 @@
-import { type InputType } from './types';
+import type { PortValue, ImageValue } from '../types';
+import { type InputType, type OutputMode } from './types';
+/** Create DM inputs are dynamic (based on inputType settings). */
+export type CreateDmNodeInputs = Record<string, PortValue | PortValue[]>;
+/** Create DM has a fixed 'output' port. */
+export interface CreateDmNodeOutputs {
+    output: ImageValue;
+}
 export type DmPlatform = 'imessage' | 'instagram';
 export interface CreateDmMessage {
     sender: 'user' | 'recipient';
@@ -29,8 +36,12 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     imessageMessageHeaderTimestampText: string;
     imessageMessageHeaderTimeInputType: InputType;
     instagramUserHasStory: boolean;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, CreateDmNodeInputs, CreateDmNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: CreateDmNodeInputs;
+    __TOutputs: CreateDmNodeOutputs;
+};
+export default _default;
 export type CreateDmNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/create-dm.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'create-dm',
     label: 'Create DM',
@@ -82,5 +85,10 @@ const definition = (0, types_1.defineNode)({
             outputs: [{ id: 'output', type: 'image', isArray: false, required: true }],
         };
     },
+    generatePreview: (_config, _ctx, cachedOutputs) => {
+        return (0, types_1.preview)({
+            output: cachedOutputs?.output ?? null,
+        });
+    },
 });
 exports.default = definition;

package/dist/automations/nodes/custom-model.d.ts

@@ -1,3 +1,11 @@
+import type { PortValue, ImageValue, VideoValue, AudioValue } from '../types';
+import { type OutputMode } from './types';
+/** Custom model inputs are dynamic (from inputParams). Input port IDs are user-defined. */
+export type CustomModelNodeInputs = Record<string, PortValue | PortValue[]>;
+/** Custom model output depends on outputType config. */
+export interface CustomModelNodeOutputs {
+    output: ImageValue | VideoValue | AudioValue;
+}
 export type CustomModelOutputType = 'image' | 'video' | 'audio';
 export interface CustomModelInputParam {
     name: string;
@@ -12,8 +20,12 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     outputType: CustomModelOutputType;
     inputParams: CustomModelInputParam[];
     apiKey: string | undefined;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, CustomModelNodeInputs, CustomModelNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: CustomModelNodeInputs;
+    __TOutputs: CustomModelNodeOutputs;
+};
+export default _default;
 export type CustomModelNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/custom-model.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'custom-model',
     label: 'Custom Model',
@@ -48,5 +51,10 @@ const definition = (0, types_1.defineNode)({
             ],
         };
     },
+    generatePreview: (_config, _ctx, cachedOutputs) => {
+        return (0, types_1.preview)({
+            output: cachedOutputs?.output ?? null,
+        });
+    },
 });
 exports.default = definition;

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

@@ -1,8 +1,20 @@
+import type { VideoValue } from '../types';
 import type { DeduplicationInput } from '../../render/types';
+import { type OutputMode } from './types';
+export interface DeduplicateNodeInputs {
+    video: VideoValue;
+}
+export interface DeduplicateNodeOutputs {
+    output: VideoValue;
+}
 declare const definition: import("./types").NodeDefinition<"generator", {
     deduplication: DeduplicationInput;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, DeduplicateNodeInputs, DeduplicateNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: DeduplicateNodeInputs;
+    __TOutputs: DeduplicateNodeOutputs;
+};
+export default _default;
 export type DeduplicateNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/deduplicate.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'deduplicate',
     label: 'Mass Repost',
@@ -32,5 +35,10 @@ const definition = (0, types_1.defineNode)({
             },
         ],
     }),
+    generatePreview: (_config, _ctx, cachedOutputs) => {
+        return (0, types_1.preview)({
+            output: cachedOutputs?.output ?? null,
+        });
+    },
 });
 exports.default = definition;

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

@@ -1,4 +1,9 @@
-import { type InputType } from './types';
+import type { PortValue } from '../types';
+import { type InputType, type OutputMode } from './types';
+/** Destructure inputs: 'array' + dynamic idx-* inputs for variable selections. */
+export type DestructureNodeInputs = Record<string, PortValue | PortValue[]>;
+/** Destructure outputs are dynamic based on selections config. */
+export type DestructureNodeOutputs = Record<string, PortValue | PortValue[]>;
 type IndexExpression = {
     type: 'single';
     index: number;
@@ -18,10 +23,14 @@ interface DestructureSelection {
 }
 declare const definition: import("./types").NodeDefinition<"generator", {
     selections: DestructureSelection[];
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
+}, DestructureNodeInputs, DestructureNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: DestructureNodeInputs;
+    __TOutputs: DestructureNodeOutputs;
+};
+export default _default;
 export type { DestructureSelection, IndexExpression };
 export type DestructureNodeConfig = typeof definition.defaults;
 /**

package/dist/automations/nodes/destructure.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexExpressionToIndexes = indexExpressionToIndexes;
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'destructure',
     label: 'Destructure',
@@ -81,6 +84,58 @@ const definition = (0, types_1.defineNode)({
         }
         return { inputs, outputs };
     },
+    generatePreview: (config, ctx, _cachedOutputs) => {
+        const result = {};
+        const inputArray = ctx.inputPreviews.array;
+        // If no input array or not an array, return nulls
+        if (!inputArray || !Array.isArray(inputArray)) {
+            for (const selection of config.selections) {
+                result[selection.portId] = null;
+            }
+            return (0, types_1.preview)(result);
+        }
+        for (const selection of config.selections) {
+            // Skip variable inputs - we don't know the index at preview time
+            if (selection.inputType === 'variable') {
+                result[selection.portId] = null;
+                continue;
+            }
+            const indexes = indexExpressionToIndexes(selection.indexExpr);
+            if (selection.indexExpr.type === 'single') {
+                // Single index - return single value
+                const item = inputArray[indexes[0]];
+                if (item === undefined) {
+                    result[selection.portId] = null;
+                }
+                else if (selection.propertyPath) {
+                    // TODO: Add discriminator field to value types to enable proper narrowing without casts
+                    // For now, cast to access property - returns undefined if property doesn't exist
+                    const value = item[selection.propertyPath];
+                    result[selection.portId] = value ?? null;
+                }
+                else {
+                    result[selection.portId] = item;
+                }
+            }
+            else {
+                // Range or list - return array of values
+                const values = indexes
+                    .map(i => {
+                    const item = inputArray[i];
+                    if (item === undefined)
+                        return undefined;
+                    if (selection.propertyPath) {
+                        // TODO: Add discriminator field to value types to enable proper narrowing
+                        return item[selection.propertyPath];
+                    }
+                    return item;
+                })
+                    .filter((v) => v !== undefined);
+                result[selection.portId] = values.length > 0 ? values : null;
+            }
+        }
+        return (0, types_1.preview)(result);
+    },
 });
 exports.default = definition;
 // =============================================================================

package/dist/automations/nodes/for-each.d.ts

@@ -1,11 +1,22 @@
-import type { BasePortType } from '../types';
-interface ForEachOutputProperty {
+import type { BasePortType, PortValue } from '../types';
+import { type OutputMode } from './types';
+/**
+ * For-each node inputs: required array input + dynamic passthrough inputs.
+ * Input port IDs are user-defined (except 'array').
+ */
+export type ForEachNodeInputs = Record<string, PortValue | PortValue[]>;
+/**
+ * For-each node outputs: optional item/index + dynamic property outputs + passthrough outputs.
+ * Output port IDs are user-defined based on config.
+ */
+export type ForEachNodeOutputs = Record<string, PortValue | PortValue[]>;
+export interface ForEachOutputProperty {
     portId: string;
     propertyPath: string;
     type: BasePortType;
     isArray: boolean;
 }
-interface ForEachInputPort {
+export interface ForEachInputPort {
     id: string;
     type: BasePortType;
     isArray: boolean;
@@ -15,9 +26,12 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     inputPorts: ForEachInputPort[];
     exposeItem: boolean;
     exposeIndex: boolean;
-    outputMode: "per-input";
+    outputMode: OutputMode;
     selectionMode: null;
-}, false>;
-export default definition;
-export type { ForEachOutputProperty, ForEachInputPort };
+}, ForEachNodeInputs, ForEachNodeOutputs, false>;
+declare const _default: typeof definition & {
+    __TInputs: ForEachNodeInputs;
+    __TOutputs: ForEachNodeOutputs;
+};
+export default _default;
 export type ForEachNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/for-each.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
+// =============================================================================
+// Node Definition
+// =============================================================================
 const definition = (0, types_1.defineNode)({
     nodeId: 'for-each',
     label: 'For Each',
@@ -80,5 +83,25 @@ const definition = (0, types_1.defineNode)({
         }
         return { inputs, outputs };
     },
+    generatePreview: (config, ctx) => {
+        const result = {};
+        // Item output - pass through the array input preview (shows one item)
+        if (config.exposeItem) {
+            result.item = ctx.inputPreviews.array ?? null;
+        }
+        // Index output - not displayable as a preview
+        if (config.exposeIndex) {
+            result.index = null;
+        }
+        // Property outputs - would need object parsing, return null for now
+        for (const prop of config.outputProperties) {
+            result[prop.portId] = null;
+        }
+        // Passthrough outputs - pass through from inputPreviews
+        for (const port of config.inputPorts) {
+            result[port.id] = ctx.inputPreviews[port.id] ?? null;
+        }
+        return (0, types_1.preview)(result);
+    },
 });
 exports.default = definition;