ugcinc 4.1.21 → 4.1.23

package/dist/nodes/media.d.ts

@@ -1,17 +0,0 @@
-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

@@ -1,40 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1,35 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,32 +0,0 @@
-"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

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

package/dist/nodes/random-route.js

@@ -1,50 +0,0 @@
-"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

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

package/dist/nodes/random.js

@@ -1,48 +0,0 @@
-"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

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

package/dist/nodes/recurrence.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition = {
-    nodeId: 'recurrence',
-    label: 'Recurring',
-    description: 'Run continuously',
-    type: 'trigger',
-    category: 'Triggers',
-    getDefaultConfig: () => ({
-        recurrenceConfig: {
-            frequencyType: 'per-day',
-            runsPerDay: 1,
-            periodDays: 7,
-            daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'],
-            timingType: 'random-window',
-            specificTimes: ['09:00'],
-            randomWindowStart: '09:00',
-            randomWindowEnd: '17:00',
-            timezone: 'America/New_York',
-        },
-    }),
-    computePorts: ({ config }) => {
-        const recurrenceConfig = config?.recurrenceConfig;
-        const outputs = [];
-        // Add account output if collection input is enabled
-        if (recurrenceConfig?.collectionInput?.enabled) {
-            outputs.push({ id: 'account', type: 'account', isArray: false, required: true });
-        }
-        // Add media outputs
-        const mediaOutputs = recurrenceConfig?.mediaInput?.outputs ?? [];
-        for (const output of mediaOutputs) {
-            outputs.push({
-                id: output.id,
-                type: output.type,
-                isArray: false,
-                required: true,
-            });
-        }
-        return {
-            inputs: [],
-            outputs,
-        };
-    },
-};
-exports.default = definition;

package/dist/nodes/save-to-media.d.ts

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

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

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition = {
-    nodeId: 'save-to-media',
-    label: 'Save To Media',
-    description: 'Save outputs to media library',
-    type: 'terminal',
-    category: 'Output',
-    getDefaultConfig: () => ({
-        saveToMediaConfig: {
-            inputs: [{ id: 'input', type: 'image' }],
-        },
-    }),
-    computePorts: ({ config }) => {
-        const saveConfig = config?.saveToMediaConfig;
-        const configInputs = saveConfig?.inputs ?? [];
-        const inputs = configInputs.map(input => ({
-            id: input.id,
-            type: input.type,
-            isArray: false,
-            required: true,
-        }));
-        return { inputs, outputs: [] };
-    },
-};
-exports.default = definition;

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

@@ -1,7 +0,0 @@
-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/nodes/screenshot-animation.js

@@ -1,36 +0,0 @@
-"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/nodes/social-audio.d.ts

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

package/dist/nodes/social-audio.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition = {
-    nodeId: 'social-audio',
-    label: 'Social Audio',
-    description: 'Select trending audio for posts',
-    type: 'source',
-    category: 'Sources',
-    getDefaultConfig: () => ({
-        urls: [],
-        selectedMediaIds: [],
-        selectionConfig: { mode: 'random' },
-    }),
-    computePorts: () => ({
-        inputs: [],
-        outputs: [
-            {
-                id: 'social-audio',
-                type: 'social_audio',
-                isArray: false,
-                required: true,
-            },
-        ],
-    }),
-};
-exports.default = definition;

package/dist/nodes/text.d.ts

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

package/dist/nodes/text.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const internal_utils_1 = require("../internal-utils");
-const definition = {
-    nodeId: 'text',
-    label: 'Text',
-    description: 'Use text collections',
-    type: 'source',
-    category: 'Sources',
-    getDefaultConfig: () => ({
-        textOptions: [],
-        selectionConfig: { mode: '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/nodes/transcript.d.ts

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

package/dist/nodes/transcript.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition = {
-    nodeId: 'transcript',
-    label: 'Transcribe',
-    description: 'Transcribe video or audio with timestamps',
-    type: 'generator',
-    category: 'Generation',
-    getDefaultConfig: () => ({
-        outputMode: 'per-input',
-    }),
-    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/nodes/types.d.ts

@@ -1,146 +0,0 @@
-/**
- * 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;
-}
-/**
- * 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/nodes/types.js

@@ -1,22 +0,0 @@
-"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;
-}