@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/executors/executor-registry.spec.js

@@ -0,0 +1,121 @@
+import {
+  createExecutorRegistry,
+  EXECUTOR_REGISTRY,
+  getExecutor,
+  getExecutorMetadata,
+  getRegisteredNodeTypes,
+  hasExecutor,
+} from '@workflow-engine/executors/executor-registry';
+import { describe, expect, it } from 'vitest';
+
+describe('executor-registry', () => {
+  describe('EXECUTOR_REGISTRY', () => {
+    it('has all expected node types', () => {
+      const types = Object.keys(EXECUTOR_REGISTRY);
+      expect(types).toContain('brand');
+      expect(types).toContain('publish');
+      expect(types).toContain('condition');
+      expect(types).toContain('delay');
+      expect(types).toContain('noop');
+    });
+  });
+  describe('getExecutor', () => {
+    it('returns executor for known type', () => {
+      const exec = getExecutor('noop');
+      expect(exec).toBeDefined();
+      expect(exec.nodeType).toBe('noop');
+    });
+    it('returns undefined for unknown type', () => {
+      expect(getExecutor('nonexistent')).toBeUndefined();
+    });
+  });
+  describe('hasExecutor', () => {
+    it('returns true for known type', () => {
+      expect(hasExecutor('brand')).toBe(true);
+    });
+    it('returns false for unknown type', () => {
+      expect(hasExecutor('nonexistent')).toBe(false);
+    });
+  });
+  describe('getRegisteredNodeTypes', () => {
+    it('returns array of node types', () => {
+      const types = getRegisteredNodeTypes();
+      expect(types.length).toBeGreaterThan(10);
+      expect(types).toContain('noop');
+    });
+  });
+  describe('getExecutorMetadata', () => {
+    it('returns metadata for known type', () => {
+      const meta = getExecutorMetadata('brand');
+      expect(meta).toBeDefined();
+      expect(meta.nodeType).toBe('brand');
+      expect(meta.requiresResolver).toBe(true);
+    });
+    it('returns undefined for unknown type', () => {
+      expect(getExecutorMetadata('nonexistent')).toBeUndefined();
+    });
+  });
+  describe('ExecutorRegistryInstance', () => {
+    it('creates registry with all executors', () => {
+      const registry = createExecutorRegistry();
+      expect(registry.has('noop')).toBe(true);
+      expect(registry.has('brand')).toBe(true);
+    });
+    it('gets typed executors', () => {
+      const registry = createExecutorRegistry();
+      expect(registry.getConditionExecutor()).toBeDefined();
+      expect(registry.getDelayExecutor()).toBeDefined();
+      expect(registry.getBrandExecutor()).toBeDefined();
+      expect(registry.getBrandContextExecutor()).toBeDefined();
+      expect(registry.getBrandAssetExecutor()).toBeDefined();
+      expect(registry.getPublishExecutor()).toBeDefined();
+      expect(registry.getTweetInputExecutor()).toBeDefined();
+      expect(registry.getTweetRemixExecutor()).toBeDefined();
+      expect(registry.getRssInputExecutor()).toBeDefined();
+      expect(registry.getSocialPublishExecutor()).toBeDefined();
+      expect(registry.getTrendTriggerExecutor()).toBeDefined();
+      expect(registry.getSoundOverlayExecutor()).toBeDefined();
+      expect(registry.getVideoInputExecutor()).toBeDefined();
+      expect(registry.getMusicSourceExecutor()).toBeDefined();
+      expect(registry.getBeatAnalysisExecutor()).toBeDefined();
+      expect(registry.getBeatSyncEditorExecutor()).toBeDefined();
+      expect(registry.getCinematicColorGradeExecutor()).toBeDefined();
+      expect(registry.getColorGradeExecutor()).toBeDefined();
+      expect(registry.getFilmGrainExecutor()).toBeDefined();
+      expect(registry.getLensEffectsExecutor()).toBeDefined();
+      expect(registry.getPostReplyExecutor()).toBeDefined();
+      expect(registry.getSendDmExecutor()).toBeDefined();
+      expect(registry.getNewFollowerTriggerExecutor()).toBeDefined();
+      expect(registry.getMentionTriggerExecutor()).toBeDefined();
+      expect(registry.getNewLikeTriggerExecutor()).toBeDefined();
+      expect(registry.getNewRepostTriggerExecutor()).toBeDefined();
+      expect(registry.getImageGenExecutor()).toBeDefined();
+      expect(registry.getKeywordTriggerExecutor()).toBeDefined();
+      expect(registry.getEngagementTriggerExecutor()).toBeDefined();
+    });
+    it('allows setting custom executor', () => {
+      const registry = createExecutorRegistry();
+      const custom = {
+        execute: async () => ({ data: null }),
+        nodeType: 'custom',
+      };
+      registry.set('custom', custom);
+      expect(registry.get('custom')).toBe(custom);
+    });
+    it('allows registering via function', () => {
+      const registry = createExecutorRegistry();
+      registry.register('myNode', async () => 'result');
+      const exec = registry.get('myNode');
+      expect(exec).toBeDefined();
+      expect(exec.nodeType).toBe('myNode');
+    });
+    it('returns undefined for wrong type cast', () => {
+      const registry = createExecutorRegistry();
+      registry.set('condition', {
+        execute: async () => ({ data: null }),
+        nodeType: 'condition',
+      });
+      expect(registry.getConditionExecutor()).toBeUndefined();
+    });
+  });
+});

package/dist/workflow-engine/src/executors/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@workflow-engine/executors/base-executor';
+export * from '@workflow-engine/executors/executor-registry';
+export * from '@workflow-engine/executors/saas';
+//# sourceMappingURL=index.d.ts.map

package/dist/workflow-engine/src/executors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/executors/index.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC;AACzD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,iCAAiC,CAAC"}

package/dist/workflow-engine/src/executors/index.js

@@ -0,0 +1,3 @@
+export * from '@workflow-engine/executors/base-executor';
+export * from '@workflow-engine/executors/executor-registry';
+export * from '@workflow-engine/executors/saas';

package/dist/workflow-engine/src/executors/saas/beat-analysis-executor.d.ts

@@ -0,0 +1,40 @@
+import { BeatSensitivity } from '@genfeedai/enums';
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface BeatAnalysisResult {
+    tempo: number;
+    beatTimestamps: number[];
+    downbeats: number[];
+    beatCount: number;
+    analysisMethod: 'aubio' | 'ffmpeg';
+    confidence: number;
+}
+export type BeatAnalyzer = (params: {
+    organizationId: string;
+    musicUrl: string;
+    minBpm: number;
+    maxBpm: number;
+    beatSensitivity: BeatSensitivity;
+}) => Promise<BeatAnalysisResult>;
+/**
+ * Beat Analysis Executor
+ *
+ * Detects tempo and beat timestamps from audio files.
+ * Uses aubio for accurate onset detection with FFmpeg fallback.
+ *
+ * Node Type: beatAnalysis
+ * Definition: @genfeedai/workflow-saas/nodes/beat-analysis.ts
+ */
+export declare class BeatAnalysisExecutor extends BaseExecutor {
+    readonly nodeType = "beatAnalysis";
+    private analyzer;
+    setAnalyzer(analyzer: BeatAnalyzer): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createBeatAnalysisExecutor(analyzer?: BeatAnalyzer): BeatAnalysisExecutor;
+//# sourceMappingURL=beat-analysis-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/beat-analysis-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beat-analysis-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/beat-analysis-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,GAAG,QAAQ,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,eAAe,CAAC;CAClC,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAElC;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,QAAQ,CAAC,QAAQ,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAA6B;IAE7C,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAIzC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA0CpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAIrC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAqC7D;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,CAAC,EAAE,YAAY,GACtB,oBAAoB,CAMtB"}

package/dist/workflow-engine/src/executors/saas/beat-analysis-executor.js

@@ -0,0 +1,83 @@
+import { BeatSensitivity } from '@genfeedai/enums';
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Beat Analysis Executor
+ *
+ * Detects tempo and beat timestamps from audio files.
+ * Uses aubio for accurate onset detection with FFmpeg fallback.
+ *
+ * Node Type: beatAnalysis
+ * Definition: @genfeedai/workflow-saas/nodes/beat-analysis.ts
+ */
+export class BeatAnalysisExecutor extends BaseExecutor {
+    nodeType = 'beatAnalysis';
+    analyzer = null;
+    setAnalyzer(analyzer) {
+        this.analyzer = analyzer;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const minBpm = node.config.minBpm;
+        if (minBpm !== undefined &&
+            (typeof minBpm !== 'number' || minBpm < 20 || minBpm > 300)) {
+            errors.push('Min BPM must be between 20 and 300');
+        }
+        const maxBpm = node.config.maxBpm;
+        if (maxBpm !== undefined &&
+            (typeof maxBpm !== 'number' || maxBpm < 20 || maxBpm > 300)) {
+            errors.push('Max BPM must be between 20 and 300');
+        }
+        if (minBpm != null && maxBpm != null && minBpm > maxBpm) {
+            errors.push('Min BPM cannot be greater than max BPM');
+        }
+        const beatSensitivity = node.config.beatSensitivity;
+        if (beatSensitivity &&
+            !Object.values(BeatSensitivity).includes(beatSensitivity)) {
+            errors.push(`Invalid beat sensitivity. Must be one of: ${Object.values(BeatSensitivity).join(', ')}`);
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 2; // Beat analysis costs 2 credits
+    }
+    async execute(input) {
+        const { node, inputs, context } = input;
+        if (!this.analyzer) {
+            throw new Error('Beat analyzer not configured');
+        }
+        const musicUrl = this.getRequiredInput(inputs, 'musicUrl');
+        const minBpm = this.getOptionalConfig(node.config, 'minBpm', 60);
+        const maxBpm = this.getOptionalConfig(node.config, 'maxBpm', 200);
+        const beatSensitivity = this.getOptionalConfig(node.config, 'beatSensitivity', BeatSensitivity.MEDIUM);
+        const result = await this.analyzer({
+            beatSensitivity,
+            maxBpm,
+            minBpm,
+            musicUrl,
+            organizationId: context.organizationId,
+        });
+        return {
+            data: {
+                beatTimestamps: result.beatTimestamps,
+                downbeats: result.downbeats,
+                tempo: result.tempo,
+            },
+            metadata: {
+                analysisMethod: result.analysisMethod,
+                beatCount: result.beatCount,
+                confidence: result.confidence,
+            },
+        };
+    }
+}
+export function createBeatAnalysisExecutor(analyzer) {
+    const executor = new BeatAnalysisExecutor();
+    if (analyzer) {
+        executor.setAnalyzer(analyzer);
+    }
+    return executor;
+}

package/dist/workflow-engine/src/executors/saas/beat-analysis-executor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=beat-analysis-executor.spec.d.ts.map

package/dist/workflow-engine/src/executors/saas/beat-analysis-executor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beat-analysis-executor.spec.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/beat-analysis-executor.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/executors/saas/beat-analysis-executor.spec.js

@@ -0,0 +1,121 @@
+import { BeatSensitivity } from '@genfeedai/enums';
+import { createBeatAnalysisExecutor } from '@workflow-engine/executors/saas/beat-analysis-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+describe('BeatAnalysisExecutor', () => {
+  describe('validate', () => {
+    it('valid defaults', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid minBpm < 20', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { minBpm: 10 },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid maxBpm > 300', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { maxBpm: 400 },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid minBpm > maxBpm', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { maxBpm: 100, minBpm: 200 },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid beatSensitivity', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { beatSensitivity: 'ultra' },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  it('estimateCost returns 2', () => {
+    expect(
+      createBeatAnalysisExecutor().estimateCost({
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'BA',
+        type: 'beatAnalysis',
+      }),
+    ).toBe(2);
+  });
+  describe('execute', () => {
+    it('throws without analyzer', async () => {
+      await expect(
+        createBeatAnalysisExecutor().execute({
+          context: ctx,
+          inputs: new Map([['musicUrl', 'http://m.mp3']]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'BA',
+            type: 'beatAnalysis',
+          },
+        }),
+      ).rejects.toThrow('analyzer');
+    });
+    it('analyzes beats', async () => {
+      const analyzer = vi.fn().mockResolvedValue({
+        analysisMethod: 'aubio',
+        beatCount: 3,
+        beatTimestamps: [0.5, 1.0],
+        confidence: 0.95,
+        downbeats: [0.5],
+        tempo: 120,
+      });
+      const exec = createBeatAnalysisExecutor(analyzer);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map([['musicUrl', 'http://m.mp3']]),
+        node: {
+          config: { beatSensitivity: BeatSensitivity.HIGH },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        },
+      });
+      expect(result.data.tempo).toBe(120);
+      expect(result.metadata?.analysisMethod).toBe('aubio');
+    });
+  });
+});

package/dist/workflow-engine/src/executors/saas/beat-sync-editor-executor.d.ts

@@ -0,0 +1,44 @@
+import { BeatSyncCutStrategy, BeatSyncTransitionType } from '@genfeedai/enums';
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface BeatSyncEditorResult {
+    outputVideoUrl: string;
+    totalClips: number;
+    totalDuration: number;
+    jobId: string;
+}
+export type BeatSyncEditor = (params: {
+    organizationId: string;
+    videoFiles: string[];
+    beatTimestamps: number[];
+    musicUrl: string;
+    cutStrategy: BeatSyncCutStrategy;
+    transitionType: BeatSyncTransitionType;
+    transitionDuration: number;
+    loopVideos: boolean;
+    shuffleOrder: boolean;
+    beatsPerClip: number;
+    customPattern?: number[];
+}) => Promise<BeatSyncEditorResult>;
+/**
+ * Beat Sync Editor Executor
+ *
+ * Cuts and assembles videos to match beat timestamps.
+ * Supports multiple cut strategies and transition types.
+ *
+ * Node Type: beatSyncEditor
+ * Definition: @genfeedai/workflow-saas/nodes/beat-sync-editor.ts
+ */
+export declare class BeatSyncEditorExecutor extends BaseExecutor {
+    readonly nodeType = "beatSyncEditor";
+    private editor;
+    setEditor(editor: BeatSyncEditor): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createBeatSyncEditorExecutor(editor?: BeatSyncEditor): BeatSyncEditorExecutor;
+//# sourceMappingURL=beat-sync-editor-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/beat-sync-editor-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beat-sync-editor-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/beat-sync-editor-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,oBAAoB;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,cAAc,EAAE,sBAAsB,CAAC;IACvC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEpC;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,SAAQ,YAAY;IACtD,QAAQ,CAAC,QAAQ,oBAAoB;IACrC,OAAO,CAAC,MAAM,CAA+B;IAE7C,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIvC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAwDpE,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM;IAoBpC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CA6G7D;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,CAAC,EAAE,cAAc,GACtB,sBAAsB,CAMxB"}

package/dist/workflow-engine/src/executors/saas/beat-sync-editor-executor.js

@@ -0,0 +1,140 @@
+import { BeatSyncCutStrategy, BeatSyncTransitionType } from '@genfeedai/enums';
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Beat Sync Editor Executor
+ *
+ * Cuts and assembles videos to match beat timestamps.
+ * Supports multiple cut strategies and transition types.
+ *
+ * Node Type: beatSyncEditor
+ * Definition: @genfeedai/workflow-saas/nodes/beat-sync-editor.ts
+ */
+export class BeatSyncEditorExecutor extends BaseExecutor {
+    nodeType = 'beatSyncEditor';
+    editor = null;
+    setEditor(editor) {
+        this.editor = editor;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const cutStrategy = node.config.cutStrategy;
+        if (cutStrategy &&
+            !Object.values(BeatSyncCutStrategy).includes(cutStrategy)) {
+            errors.push(`Invalid cut strategy. Must be one of: ${Object.values(BeatSyncCutStrategy).join(', ')}`);
+        }
+        const transitionType = node.config.transitionType;
+        if (transitionType &&
+            !Object.values(BeatSyncTransitionType).includes(transitionType)) {
+            errors.push(`Invalid transition type. Must be one of: ${Object.values(BeatSyncTransitionType).join(', ')}`);
+        }
+        const transitionDuration = node.config.transitionDuration;
+        if (transitionDuration !== undefined &&
+            (typeof transitionDuration !== 'number' ||
+                transitionDuration < 0 ||
+                transitionDuration > 1000)) {
+            errors.push('Transition duration must be between 0 and 1000 milliseconds');
+        }
+        const beatsPerClip = node.config.beatsPerClip;
+        if (beatsPerClip !== undefined &&
+            (typeof beatsPerClip !== 'number' ||
+                beatsPerClip < 1 ||
+                beatsPerClip > 16)) {
+            errors.push('Beats per clip must be between 1 and 16');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(node) {
+        // Cost based on expected processing complexity
+        const beatsPerClip = node.config.beatsPerClip || 1;
+        const transitionType = node.config.transitionType;
+        let baseCost = 5; // Base video processing cost
+        // More clips = more processing
+        if (beatsPerClip === 1) {
+            baseCost += 3; // Maximum clips
+        }
+        // Transitions add processing overhead
+        if (transitionType !== BeatSyncTransitionType.CUT) {
+            baseCost += 2;
+        }
+        return baseCost;
+    }
+    async execute(input) {
+        const { node, inputs, context } = input;
+        if (!this.editor) {
+            throw new Error('Beat sync editor not configured');
+        }
+        // Get required inputs
+        const rawVideoFiles = inputs.get('videoFiles');
+        let videoFiles;
+        if (Array.isArray(rawVideoFiles)) {
+            videoFiles = rawVideoFiles.filter((f) => typeof f === 'string');
+        }
+        else if (typeof rawVideoFiles === 'string') {
+            videoFiles = [rawVideoFiles];
+        }
+        else {
+            throw new Error('Missing required input: videoFiles');
+        }
+        if (videoFiles.length === 0) {
+            throw new Error('At least one video file is required');
+        }
+        const rawBeatTimestamps = inputs.get('beatTimestamps');
+        let beatTimestamps;
+        if (Array.isArray(rawBeatTimestamps)) {
+            beatTimestamps = rawBeatTimestamps.filter((t) => typeof t === 'number');
+        }
+        else if (typeof rawBeatTimestamps === 'object' &&
+            rawBeatTimestamps !== null) {
+            // Handle case where beat analysis returns an object with beatTimestamps property
+            const beatData = rawBeatTimestamps;
+            beatTimestamps = beatData.beatTimestamps || [];
+        }
+        else {
+            throw new Error('Missing required input: beatTimestamps');
+        }
+        if (beatTimestamps.length === 0) {
+            throw new Error('At least one beat timestamp is required');
+        }
+        const musicUrl = this.getRequiredInput(inputs, 'musicUrl');
+        // Get configuration
+        const cutStrategy = this.getOptionalConfig(node.config, 'cutStrategy', BeatSyncCutStrategy.EVERY_BEAT);
+        const transitionType = this.getOptionalConfig(node.config, 'transitionType', BeatSyncTransitionType.CUT);
+        const transitionDuration = this.getOptionalConfig(node.config, 'transitionDuration', 50);
+        const loopVideos = this.getOptionalConfig(node.config, 'loopVideos', true);
+        const shuffleOrder = this.getOptionalConfig(node.config, 'shuffleOrder', false);
+        const beatsPerClip = this.getOptionalConfig(node.config, 'beatsPerClip', 1);
+        const customPattern = this.getOptionalConfig(node.config, 'customPattern', []);
+        const result = await this.editor({
+            beatsPerClip,
+            beatTimestamps,
+            customPattern,
+            cutStrategy,
+            loopVideos,
+            musicUrl,
+            organizationId: context.organizationId,
+            shuffleOrder,
+            transitionDuration,
+            transitionType,
+            videoFiles,
+        });
+        return {
+            data: result.outputVideoUrl,
+            metadata: {
+                jobId: result.jobId,
+                totalClips: result.totalClips,
+                totalDuration: result.totalDuration,
+            },
+        };
+    }
+}
+export function createBeatSyncEditorExecutor(editor) {
+    const executor = new BeatSyncEditorExecutor();
+    if (editor) {
+        executor.setEditor(editor);
+    }
+    return executor;
+}

package/dist/workflow-engine/src/executors/saas/beat-sync-editor-executor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=beat-sync-editor-executor.spec.d.ts.map

package/dist/workflow-engine/src/executors/saas/beat-sync-editor-executor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beat-sync-editor-executor.spec.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/beat-sync-editor-executor.spec.ts"],"names":[],"mappings":""}