ugcinc 3.84.6 → 3.85.0

package/dist/render/utils/text.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Text utilities for measuring and wrapping text
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapText = wrapText;
+exports.calculateLineWidth = calculateLineWidth;
+exports.getBorderRadii = getBorderRadii;
+exports.parseHexColor = parseHexColor;
+exports.hexToRgba = hexToRgba;
+exports.getSFProLetterSpacing = getSFProLetterSpacing;
+/**
+ * Wrap text to fit within a specific width
+ * Accounts for letter spacing when measuring text width
+ */
+function wrapText({ text, maxWidth, letterSpacing = 0, textWrap = 'word', maxLines = 0, measureText, }) {
+    const lines = [];
+    if (textWrap === 'none') {
+        lines.push(text);
+        return lines;
+    }
+    const words = textWrap === 'word' ? text.split(' ') : text.split('');
+    let currentLine = '';
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        if (!word)
+            continue;
+        const testLine = currentLine + (currentLine ? (textWrap === 'word' ? ' ' : '') : '') + word;
+        // Account for letter spacing
+        const charCount = [...testLine].length;
+        const extraSpacing = charCount > 1 ? (charCount - 1) * letterSpacing : 0;
+        const totalWidth = measureText(testLine) + extraSpacing;
+        if (totalWidth > maxWidth && currentLine) {
+            lines.push(currentLine);
+            currentLine = word;
+            if (maxLines && lines.length >= maxLines) {
+                break;
+            }
+        }
+        else {
+            currentLine = testLine;
+        }
+    }
+    if (currentLine && (!maxLines || lines.length < maxLines)) {
+        lines.push(currentLine);
+    }
+    // Handle overflow
+    if (maxLines && lines.length > maxLines) {
+        lines.splice(maxLines);
+    }
+    return lines;
+}
+/**
+ * Calculate line width with letter spacing
+ */
+function calculateLineWidth({ line, letterSpacing, measureText, }) {
+    const chars = [...line];
+    let width = 0;
+    for (const char of chars) {
+        width += measureText(char) + letterSpacing;
+    }
+    // Remove extra letter spacing after last character
+    if (chars.length > 0) {
+        width -= letterSpacing;
+    }
+    return width;
+}
+/**
+ * Convert borderRadius value to array format for roundRect()
+ * Returns [topLeft, topRight, bottomRight, bottomLeft] or null if no rounding needed
+ */
+function getBorderRadii(borderRadius) {
+    if (!borderRadius)
+        return null;
+    if (typeof borderRadius === 'number') {
+        if (borderRadius <= 0)
+            return null;
+        return [borderRadius, borderRadius, borderRadius, borderRadius];
+    }
+    const topLeft = borderRadius.topLeft ?? 0;
+    const topRight = borderRadius.topRight ?? 0;
+    const bottomRight = borderRadius.bottomRight ?? 0;
+    const bottomLeft = borderRadius.bottomLeft ?? 0;
+    // Check if any corner has radius
+    if (topLeft <= 0 && topRight <= 0 && bottomRight <= 0 && bottomLeft <= 0) {
+        return null;
+    }
+    return [topLeft, topRight, bottomRight, bottomLeft];
+}
+/**
+ * Parse hex color to RGB values
+ */
+function parseHexColor(hex) {
+    const cleanHex = hex.replace('#', '');
+    return {
+        r: parseInt(cleanHex.substring(0, 2), 16),
+        g: parseInt(cleanHex.substring(2, 4), 16),
+        b: parseInt(cleanHex.substring(4, 6), 16),
+    };
+}
+/**
+ * Convert hex color and opacity to rgba string
+ */
+function hexToRgba(hex, opacity = 100) {
+    const { r, g, b } = parseHexColor(hex);
+    return `rgba(${r}, ${g}, ${b}, ${opacity / 100})`;
+}
+/**
+ * SF Pro tracking table extracted from the font's `trak` table.
+ * Maps font sizes to letter-spacing values in pixels.
+ * These values are calculated from the font's FUnits using: (FUnits / 2048) * fontSize
+ */
+const SF_PRO_TRACKING = {
+    6: 0.240234,
+    9: 0.166992,
+    10: 0.117188,
+    11: 0.064453,
+    12: 0.000000,
+    13: -0.076172,
+    14: -0.150391,
+    15: -0.234375,
+    16: -0.312500,
+    17: -0.431641,
+    20: -0.449219,
+    22: -0.257812,
+    24: 0.070312,
+    28: 0.382812,
+    32: 0.406250,
+    36: 0.369141,
+    50: 0.341797,
+    64: 0.218750,
+    80: 0.000000,
+    100: 0.000000,
+    138: 0.000000,
+};
+/**
+ * Get the SF Pro letter-spacing value for a given font size.
+ * Uses linear interpolation between known tracking values from the font's trak table.
+ * This matches iOS's Core Text rendering behavior.
+ *
+ * @param fontSize - The font size in pixels
+ * @returns The letter-spacing value in pixels
+ */
+function getSFProLetterSpacing(fontSize) {
+    const sizes = Object.keys(SF_PRO_TRACKING).map(Number).sort((a, b) => a - b);
+    // Ensure we have at least one size
+    const firstSize = sizes[0];
+    const lastSize = sizes[sizes.length - 1];
+    if (firstSize === undefined || lastSize === undefined) {
+        return 0; // Fallback if no sizes defined
+    }
+    // Find bounding sizes for interpolation
+    let lower = firstSize;
+    let upper = lastSize;
+    for (let i = 0; i < sizes.length - 1; i++) {
+        const current = sizes[i];
+        const next = sizes[i + 1];
+        if (current !== undefined && next !== undefined && current <= fontSize && next >= fontSize) {
+            lower = current;
+            upper = next;
+            break;
+        }
+    }
+    // Return exact value if below or above range
+    const lowerValue = SF_PRO_TRACKING[lower];
+    const upperValue = SF_PRO_TRACKING[upper];
+    if (lowerValue === undefined || upperValue === undefined) {
+        return 0; // Fallback
+    }
+    if (fontSize <= lower)
+        return lowerValue;
+    if (fontSize >= upper)
+        return upperValue;
+    // Linear interpolation
+    const t = (fontSize - lower) / (upper - lower);
+    return lowerValue + t * (upperValue - lowerValue);
+}

package/dist/render/utils/timeline.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Timeline utility functions for video editor
+ *
+ * These functions calculate segment positions on the timeline based on
+ * the segment/overlay timing model. Used by both the webapp UI and
+ * the VideoEditorComposition for rendering.
+ */
+import type { VideoEditorSegment, VideoEditorChannel, SegmentTimelinePosition, TimeMode } from '../types/video';
+import type { TimeValue } from '../types/base';
+/**
+ * Create a default TimeValue for segment offsets
+ */
+export declare function defaultOffset(mode?: TimeMode): TimeValue;
+/**
+ * Get base segments (no parentId) for a channel
+ * Base segments are the primary timeline elements that overlays attach to
+ */
+export declare function getBaseSegments(channel: VideoEditorChannel): VideoEditorSegment[];
+/**
+ * Get overlays for a specific parent segment (or global overlays if parentId is null)
+ */
+export declare function getOverlays(channel: VideoEditorChannel, parentId: string | null): VideoEditorSegment[];
+/**
+ * Calculate segment position on timeline
+ *
+ * For base segments:
+ * - Position is calculated from offset and previous segments
+ * - Duration is from the duration property or default (5 seconds)
+ *
+ * For overlay segments:
+ * - Position is calculated relative to parent using relativeStart/relativeEnd
+ * - relativeStart/relativeEnd are fractions (0-1) of parent duration
+ */
+export declare function getSegmentTimelinePosition(segment: VideoEditorSegment, baseSegments: VideoEditorSegment[], channel: VideoEditorChannel): SegmentTimelinePosition;
+/**
+ * Check if a segment is visible at a given time
+ */
+export declare function isSegmentVisibleAtTime(segment: VideoEditorSegment, time: number, channel: VideoEditorChannel): boolean;
+/**
+ * Calculate estimated total duration based on segments
+ */
+export declare function calculateEstimatedDuration(channels: VideoEditorChannel[]): number;
+/**
+ * Calculate the timeline content end time (used for both ruler and scroll width)
+ */
+export declare function calculateTimelineContentEnd(channel: VideoEditorChannel): number;
+/**
+ * Format time in mm:ss.ms
+ */
+export declare function formatTime(ms: number): string;
+/**
+ * Parse time string to milliseconds
+ */
+export declare function parseTime(timeStr: string): number;
+/**
+ * Generate a unique segment ID
+ */
+export declare function generateSegmentId(): string;
+/**
+ * Generate a unique overlay ID
+ */
+export declare function generateOverlayId(): string;

package/dist/render/utils/timeline.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Timeline utility functions for video editor
+ *
+ * These functions calculate segment positions on the timeline based on
+ * the segment/overlay timing model. Used by both the webapp UI and
+ * the VideoEditorComposition for rendering.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOffset = defaultOffset;
+exports.getBaseSegments = getBaseSegments;
+exports.getOverlays = getOverlays;
+exports.getSegmentTimelinePosition = getSegmentTimelinePosition;
+exports.isSegmentVisibleAtTime = isSegmentVisibleAtTime;
+exports.calculateEstimatedDuration = calculateEstimatedDuration;
+exports.calculateTimelineContentEnd = calculateTimelineContentEnd;
+exports.formatTime = formatTime;
+exports.parseTime = parseTime;
+exports.generateSegmentId = generateSegmentId;
+exports.generateOverlayId = generateOverlayId;
+/**
+ * Create a default TimeValue for segment offsets
+ */
+function defaultOffset(mode = 'flexible') {
+    return mode === 'flexible'
+        ? { type: 'relative', value: 0 }
+        : { type: 'absolute', value: 0 };
+}
+/**
+ * Get base segments (no parentId) for a channel
+ * Base segments are the primary timeline elements that overlays attach to
+ */
+function getBaseSegments(channel) {
+    return channel.segments.filter(s => s.parentId === undefined);
+}
+/**
+ * Get overlays for a specific parent segment (or global overlays if parentId is null)
+ */
+function getOverlays(channel, parentId) {
+    return channel.segments.filter(s => s.parentId === (parentId ?? undefined));
+}
+/**
+ * Calculate segment position on timeline
+ *
+ * For base segments:
+ * - Position is calculated from offset and previous segments
+ * - Duration is from the duration property or default (5 seconds)
+ *
+ * For overlay segments:
+ * - Position is calculated relative to parent using relativeStart/relativeEnd
+ * - relativeStart/relativeEnd are fractions (0-1) of parent duration
+ */
+function getSegmentTimelinePosition(segment, baseSegments, channel) {
+    // For overlays, calculate based on parent
+    if (segment.parentId) {
+        const parent = channel.segments.find(s => s.id === segment.parentId);
+        if (parent) {
+            const parentPos = getSegmentTimelinePosition(parent, baseSegments, channel);
+            const relStart = segment.relativeStart ?? 0;
+            const relEnd = segment.relativeEnd ?? 1;
+            return {
+                startMs: parentPos.startMs + (parentPos.durationMs * relStart),
+                durationMs: parentPos.durationMs * (relEnd - relStart),
+            };
+        }
+    }
+    // For base segments, calculate based on order
+    const baseIndex = baseSegments.findIndex(s => s.id === segment.id);
+    let accumulatedTime = 0;
+    for (let i = 0; i < baseIndex; i++) {
+        const prev = baseSegments[i];
+        if (prev) {
+            accumulatedTime += prev.duration?.type === 'absolute'
+                ? prev.duration.value
+                : 5000; // Default 5 seconds
+        }
+    }
+    const startMs = segment.offset.type === 'absolute'
+        ? segment.offset.value
+        : accumulatedTime;
+    const durationMs = segment.duration?.type === 'absolute'
+        ? segment.duration.value
+        : 5000; // Default 5 seconds
+    return { startMs, durationMs };
+}
+/**
+ * Check if a segment is visible at a given time
+ */
+function isSegmentVisibleAtTime(segment, time, channel) {
+    const baseSegments = getBaseSegments(channel);
+    const { startMs, durationMs } = getSegmentTimelinePosition(segment, baseSegments, channel);
+    const endMs = startMs + durationMs;
+    return time >= startMs && time < endMs;
+}
+/**
+ * Calculate estimated total duration based on segments
+ */
+function calculateEstimatedDuration(channels) {
+    let maxDuration = 5000; // Minimum 5 seconds
+    for (const channel of channels) {
+        let channelTime = 0;
+        for (const segment of channel.segments) {
+            // Skip overlays - they don't extend the timeline
+            if (segment.parentId)
+                continue;
+            // For fixed timing, use the actual offset
+            if (segment.offset.type === 'absolute') {
+                channelTime = segment.offset.value;
+            }
+            else {
+                channelTime += 5000; // Estimate for relative
+            }
+            if (segment.duration?.type === 'absolute') {
+                channelTime += segment.duration.value;
+            }
+            else {
+                channelTime += 5000; // Estimate
+            }
+        }
+        maxDuration = Math.max(maxDuration, channelTime);
+    }
+    return maxDuration;
+}
+/**
+ * Calculate the timeline content end time (used for both ruler and scroll width)
+ */
+function calculateTimelineContentEnd(channel) {
+    const baseSegments = getBaseSegments(channel);
+    let lastEnd = 0;
+    for (const segment of baseSegments) {
+        const { startMs, durationMs } = getSegmentTimelinePosition(segment, baseSegments, channel);
+        lastEnd = Math.max(lastEnd, startMs + durationMs);
+    }
+    // Add 2 seconds for "Add Segment" button space, round up to nearest second
+    return Math.ceil((lastEnd + 2000) / 1000) * 1000;
+}
+/**
+ * Format time in mm:ss.ms
+ */
+function formatTime(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    const milliseconds = Math.floor((ms % 1000) / 10);
+    return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${milliseconds.toString().padStart(2, '0')}`;
+}
+/**
+ * Parse time string to milliseconds
+ */
+function parseTime(timeStr) {
+    const parts = timeStr.split(':');
+    if (parts.length !== 2)
+        return 0;
+    const [minStr, secPart] = parts;
+    const minutes = parseInt(minStr ?? '0', 10) || 0;
+    const secParts = (secPart ?? '0').split('.');
+    const seconds = parseInt(secParts[0] ?? '0', 10) || 0;
+    const ms = parseInt((secParts[1] ?? '0').padEnd(2, '0').slice(0, 2), 10) * 10 || 0;
+    return (minutes * 60 + seconds) * 1000 + ms;
+}
+/**
+ * Generate a unique segment ID
+ */
+function generateSegmentId() {
+    return `segment-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+ * Generate a unique overlay ID
+ */
+function generateOverlayId() {
+    return `overlay-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}

package/dist/render.d.ts

@@ -1,5 +1,5 @@
 import type { ApiResponse } from './types';
-import type { ImageEditorNodeConfig, VideoEditorNodeConfig, DeduplicationInput } from 'ugcinc-render';
+import type { ImageEditorNodeConfig, VideoEditorNodeConfig, DeduplicationInput } from './render/types';
 export interface RenderJobResponse {
     job_id: string;
     status: string;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { ImageEditorElement, ImageEditorNodeConfig, DimensionPresetKey, VideoEditorNodeConfig, VideoEditorChannel, VideoEditorSegment, VideoEditorVideoSegment, VideoEditorAudioSegment, VideoEditorImageSegment, VideoEditorTextSegment, VideoEditorImageSequenceSegment, VideoEditorVideoSequenceSegment, TimeValue, TimeMode, SegmentTimelinePosition, DeduplicationInput } from 'ugcinc-render';
+import type { ImageEditorElement, ImageEditorNodeConfig, DimensionPresetKey, VideoEditorNodeConfig, VideoEditorChannel, VideoEditorSegment, VideoEditorVideoSegment, VideoEditorAudioSegment, VideoEditorImageSegment, VideoEditorTextSegment, VideoEditorImageSequenceSegment, VideoEditorVideoSequenceSegment, TimeValue, TimeMode, SegmentTimelinePosition, DeduplicationInput } from './render/types';
 /**
  * API response types
  */
@@ -471,6 +471,10 @@ export interface ImageEditorNodeOutput extends Record<string, unknown>, NodeOutp
     height?: number;
     aspectRatio?: string;
 }
+export interface VideoEditorNodeInput extends Record<string, unknown> {
+    type: 'video-composer';
+    editor: VideoEditorNodeConfig;
+}
 export interface EditorConfig extends BaseEditorConfig {
     channels: Array<{
         id: string;
@@ -751,24 +755,24 @@ export type StaticSegment = ImageSegment | TextSegment;
 /**
  * Automation types
  */
-export type MediaType = 'video' | 'image' | 'audio' | 'text' | 'account' | 'date' | 'social_audio' | 'boolean';
+export type MediaType = 'video' | 'image' | 'audio' | 'text';
 /**
  * Array types for collections
  */
-export type ArrayType = 'image[]' | 'video[]' | 'audio[]' | 'text[]' | 'object[]' | 'account[]' | 'social_audio[]' | 'boolean[]';
+export type ArrayType = 'image[]' | 'video[]' | 'audio[]' | 'text[]' | 'object[]';
 /**
  * Extended port types (includes non-media types for special nodes)
  */
-export type PortType = MediaType | 'number' | 'boolean' | 'object' | ArrayType;
+export type PortType = MediaType | 'number' | 'boolean' | 'object' | 'account' | 'date' | 'social_audio' | ArrayType;
 /**
  * Selection order configuration for media nodes
  */
 export type SelectionMode = 'random' | 'sequential';
 export type ExhaustionBehavior = 'restart' | 'error';
 export interface SelectionConfig {
-    mode: SelectionMode;
-    enforceUniqueness: boolean;
-    exhaustionBehavior: ExhaustionBehavior;
+    mode?: SelectionMode;
+    enforceUniqueness?: boolean;
+    exhaustionBehavior?: ExhaustionBehavior;
 }
 export interface SelectionState {
     usedIndices: number[];
@@ -809,14 +813,26 @@ export interface NodePort {
     /** Schema of array items (when this port outputs an array) */
     itemSchema?: Record<string, PropertySchema>;
 }
+/**
+ * Simplified port definition for database storage.
+ * Uses string type since PortType union gets serialized to JSON.
+ */
+export interface ResolvedPort {
+    id: string;
+    type: string;
+    required: boolean;
+    /** Schema of array items (when this port outputs an array) */
+    itemSchema?: Record<string, PropertySchema>;
+}
 /**
  * Resolved ports for nodes with dynamic inputs/outputs.
  * Stored in node config when the automation is saved, allowing validation
  * without needing to resolve ports at validation time.
+ * Note: Uses simplified ResolvedPort type for database compatibility.
  */
 export interface ResolvedPorts {
-    inputs: NodePort[];
-    outputs: NodePort[];
+    inputs: ResolvedPort[];
+    outputs: ResolvedPort[];
 }
 /**
  * Functional category for automation nodes
@@ -849,7 +865,7 @@ export interface NodeControlConfig {
      */
     isInitializer?: boolean;
 }
-export type NodeTypeEnum = 'social-audio' | 'text' | 'media' | 'video-import' | 'image-composer' | 'video-composer' | 'generate-image' | 'generate-video' | 'custom-model' | 'llm' | 'output' | 'manual-trigger' | 'recurrence' | 'compose-workflow' | 'account' | 'auto-post' | 'save-to-media' | 'deduplicate' | 'for-each' | 'random' | 'random-route' | 'branch' | 'if' | 'not' | 'transcript' | 'auto-caption' | 'screenshot-animation' | 'create-dm' | 'collect' | 'destructure';
+export type NodeTypeEnum = 'social-audio' | 'text' | 'media' | 'video-import' | 'image-composer' | 'video-composer' | 'generate-image' | 'generate-video' | 'custom-model' | 'llm' | 'output' | 'manual-trigger' | 'recurrence' | 'compose-workflow' | 'account' | 'auto-post' | 'save-to-media' | 'deduplicate' | 'for-each' | 'for-each-value' | 'random' | 'random-route' | 'branch' | 'if' | 'not' | 'transcript' | 'auto-caption' | 'screenshot-animation' | 'create-dm' | 'collect' | 'destructure';
 export interface OutputSchemaProperty {
     type: 'string' | 'number' | 'boolean' | 'array' | 'object';
     items?: 'string' | 'number' | 'boolean';
@@ -909,6 +925,10 @@ export interface LLMNodeConfig {
 export type ImageGenerationTextModel = 'fal-ai/gemini-3-pro-image-preview' | 'fal-ai/nano-banana-pro' | 'fal-ai/nano-banana' | 'fal-ai/gpt-image-1/text-to-image';
 export type ImageGenerationEditModel = 'fal-ai/gemini-3-pro-image-preview/edit' | 'fal-ai/nano-banana-pro/edit' | 'fal-ai/nano-banana/edit' | 'fal-ai/gpt-image-1/edit-image';
 export type ImageGenerationModel = ImageGenerationTextModel | ImageGenerationEditModel;
+/**
+ * Type guard to check if model is an edit/inpaint model
+ */
+export declare function isEditModel(model: ImageGenerationModel): model is ImageGenerationEditModel;
 /**
  * Image Generation Node Configuration
  */
@@ -979,13 +999,20 @@ export interface WorkflowNodeDefinition {
 }
 export interface OutputInput {
     id: string;
-    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio' | 'account' | 'boolean' | 'object';
-    isArray?: boolean;
-    /** Schema for object types - describes the structure of the object */
-    itemSchema?: Record<string, PropertySchema>;
+    title: string;
+    type: 'image' | 'video' | 'audio' | 'text';
+    /** Individual tag for this input (overrides global tag) */
+    tag?: string;
 }
 export interface OutputNodeConfig {
     inputs: OutputInput[];
+    /** Which input is the main visual preview for the workflow */
+    mainPreviewInputId?: string;
+    saveToMedia?: boolean;
+    globalTag?: string;
+    makeUnique?: boolean;
+    createPost?: boolean;
+    requireReview?: boolean;
 }
 /**
  * Level 3 (deepest) object schema field - primitives only, no further nesting
@@ -1222,7 +1249,6 @@ export interface AutoPostNodeConfig {
  */
 export interface SaveToMediaInput {
     id: string;
-    title: string;
     type: 'image' | 'video' | 'audio' | 'text';
     /** Optional individual tag for this input (overrides global tag) */
     tag?: string;
@@ -1232,11 +1258,11 @@ export interface SaveToMediaInput {
  */
 export interface SaveToMediaNodeConfig {
     /** Dynamic inputs to save */
-    inputs?: SaveToMediaInput[];
+    inputs: SaveToMediaInput[];
     /** Global tag applied to all saved items */
     globalTag?: string;
     /** If true, append date in mm-dd-yy format to tag */
-    includeDateTag?: boolean;
+    tagWithDate?: boolean;
     /** If true, append run ID to make tags unique */
     makeUnique?: boolean;
 }
@@ -1617,6 +1643,10 @@ export interface DestructureNodeConfig {
 export type VideoGenerationTextToVideoModel = 'fal-ai/veo3.1' | 'fal-ai/veo3' | 'fal-ai/veo3/fast' | 'fal-ai/kling-video/v2.6/pro/text-to-video' | 'fal-ai/kling-video/v2.5/pro/text-to-video' | 'fal-ai/luma-dream-machine/ray-2' | 'fal-ai/luma-dream-machine/ray-2-flash' | 'fal-ai/minimax/hailuo-2.3/pro/text-to-video' | 'wan/v2.6/text-to-video' | 'fal-ai/sora-2/text-to-video';
 export type VideoGenerationImageToVideoModel = 'fal-ai/veo3.1/image-to-video' | 'fal-ai/veo3/image-to-video' | 'fal-ai/kling-video/v2.6/pro/image-to-video' | 'fal-ai/kling-video/v2.5/pro/image-to-video' | 'fal-ai/luma-dream-machine/ray-2/image-to-video' | 'fal-ai/luma-dream-machine/ray-2-flash/image-to-video' | 'fal-ai/minimax/hailuo-2.3/pro/image-to-video' | 'wan/v2.6/image-to-video' | 'fal-ai/sora-2/image-to-video/pro';
 export type VideoGenerationModel = VideoGenerationTextToVideoModel | VideoGenerationImageToVideoModel;
+/**
+ * Type guard to check if model is an image-to-video model
+ */
+export declare function isImageToVideoModel(model: VideoGenerationModel): model is VideoGenerationImageToVideoModel;
 /**
  * Video Generation node configuration - AI video generation
  */
@@ -2059,3 +2089,92 @@ export interface AutomationRunExport {
         edges: ExportedEdge[];
     };
 }
+/**
+ * Account object that flows through edges for posting
+ */
+export interface AccountData {
+    id: string;
+    username: string;
+    platform: 'tiktok';
+    displayName?: string;
+    profilePicUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Output structure for flow control nodes (if, random-route).
+ * Contains values for selected ports and list of skipped port IDs.
+ */
+export interface FlowControlOutput {
+    values: Record<string, unknown>;
+    skippedPorts: string[];
+}
+/**
+ * Node types array for runtime use
+ */
+export declare const NodeTypes: readonly ["social-audio", "text", "media", "video-import", "image-composer", "video-composer", "generate-image", "generate-video", "custom-model", "llm", "output", "manual-trigger", "recurrence", "compose-workflow", "account", "auto-post", "save-to-media", "deduplicate", "for-each", "for-each-value", "transcript", "auto-caption", "screenshot-animation", "random", "random-route", "branch", "if", "not", "create-dm", "collect", "destructure"];
+/**
+ * Node type enum derived from NodeTypes const array
+ * This is the canonical type - use this instead of the string union NodeTypeEnum
+ */
+export type NodeType = typeof NodeTypes[number];
+/**
+ * Context passed to executor-based node execution.
+ * Replaces the complex outputMap/iteration/portOffsets pattern with simple inputs.
+ */
+export interface ExecutorContext {
+    /** Database ID of this executor */
+    executorId: string;
+    /** Run ID this executor belongs to */
+    runId: string;
+    /** Template node ID this executor was created from */
+    templateNodeId: string;
+    /** Index of this executor (0, 1, 2...) for the same template node */
+    executorIndex: number;
+    /** Node type */
+    type: NodeType;
+    /** Node config (includes assignedValue for source nodes) */
+    config: Record<string, unknown>;
+    /** Input values read from incoming edges (portId -> value) */
+    inputs: Record<string, unknown>;
+}
+/**
+ * Executor for synchronous nodes.
+ * Much simpler than the old NodeControlConfig - just takes context and returns output.
+ */
+export interface NodeExecutor<TOutput = unknown> {
+    type: NodeType;
+    /**
+     * Execute the node and return a single output value.
+     * For multi-output nodes (like LLM), return an object with output fields.
+     */
+    execute: (ctx: ExecutorContext) => Promise<TOutput>;
+}
+/**
+ * Async job status for executor-based async nodes
+ */
+export type ExecutorAsyncJobStatus<TOutput = unknown> = {
+    status: 'pending';
+} | {
+    status: 'completed';
+    output: TOutput;
+} | {
+    status: 'failed';
+    error: string;
+};
+/**
+ * Executor for asynchronous nodes (video-editor, generate-image, workflow).
+ * Uses submit/poll pattern for durable workflows.
+ */
+export interface AsyncNodeExecutor<TOutput = unknown> extends Omit<NodeExecutor<TOutput>, 'execute'> {
+    isAsync: true;
+    /** Submit job - returns job ID for polling */
+    submitJob: (ctx: ExecutorContext) => Promise<{
+        jobId: string;
+    }>;
+    /** Check job status - called by orchestrator with workflow sleep between calls */
+    checkStatus: (jobId: string, ctx: ExecutorContext) => Promise<ExecutorAsyncJobStatus<TOutput>>;
+}
+/**
+ * Type guard to check if an executor is async
+ */
+export declare function isAsyncExecutor<T>(executor: NodeExecutor<T> | AsyncNodeExecutor<T>): executor is AsyncNodeExecutor<T>;