@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/templates/cinematic-video.template.js

@@ -0,0 +1,304 @@
+/**
+ * Cinematic Video Workflow Template
+ *
+ * Workflow chain:
+ * 1. CAST prompt generation
+ * 2. Video generation (model TBD: Sora/Kling/etc)
+ * 3. Upscale pass 1
+ * 4. Upscale pass 2 (optional)
+ * 5. Color grade (from preset)
+ * 6. Film grain (from preset)
+ * 7. Lens effects (from preset)
+ * 8. Platform export
+ */
+export const CINEMATIC_VIDEO_TEMPLATE = {
+    category: 'video-generation',
+    description: 'Complete cinematic video generation pipeline using CAST prompt framework with professional post-processing',
+    edges: [
+        {
+            id: 'edge-1',
+            source: 'cast-prompt-1',
+            sourceHandle: 'output',
+            target: 'video-gen-1',
+            targetHandle: 'prompt',
+        },
+        {
+            id: 'edge-2',
+            source: 'video-gen-1',
+            sourceHandle: 'output',
+            target: 'upscale-1',
+            targetHandle: 'input',
+        },
+        {
+            id: 'edge-3',
+            source: 'upscale-1',
+            sourceHandle: 'output',
+            target: 'upscale-2',
+            targetHandle: 'input',
+        },
+        {
+            id: 'edge-4',
+            source: 'upscale-2',
+            sourceHandle: 'output',
+            target: 'color-grade-1',
+            targetHandle: 'input',
+        },
+        {
+            id: 'edge-5',
+            source: 'cast-prompt-1',
+            sourceHandle: 'preset',
+            target: 'color-grade-1',
+            targetHandle: 'preset-config',
+        },
+        {
+            id: 'edge-6',
+            source: 'color-grade-1',
+            sourceHandle: 'output',
+            target: 'film-grain-1',
+            targetHandle: 'input',
+        },
+        {
+            id: 'edge-7',
+            source: 'cast-prompt-1',
+            sourceHandle: 'preset',
+            target: 'film-grain-1',
+            targetHandle: 'preset-config',
+        },
+        {
+            id: 'edge-8',
+            source: 'film-grain-1',
+            sourceHandle: 'output',
+            target: 'lens-effects-1',
+            targetHandle: 'input',
+        },
+        {
+            id: 'edge-9',
+            source: 'cast-prompt-1',
+            sourceHandle: 'preset',
+            target: 'lens-effects-1',
+            targetHandle: 'preset-config',
+        },
+        {
+            id: 'edge-10',
+            source: 'lens-effects-1',
+            sourceHandle: 'output',
+            target: 'platform-export-1',
+            targetHandle: 'input',
+        },
+    ],
+    id: 'cinematic-video-ugc',
+    metadata: {
+        createdAt: new Date().toISOString(),
+        tags: ['video', 'cinematic', 'ugc', 'ai-generation', 'cast-framework'],
+        version: '1.0.0',
+    },
+    name: 'UGC Cinematic Video Workflow',
+    nodes: [
+        // Node 1: CAST Prompt Generator
+        {
+            config: {
+                action: '',
+                cameraMovement: 'dolly',
+                colorPalette: '',
+                lighting: '',
+                mood: '',
+                presetId: 'hollywood_blockbuster',
+                subject: '',
+            },
+            id: 'cast-prompt-1',
+            inputs: [],
+            label: 'CAST Prompt Generator',
+            type: 'cast-prompt-generator',
+        },
+        // Node 2: Video Generation
+        {
+            config: {
+                aspectRatio: '16:9',
+                duration: 5,
+                fps: 24,
+                model: 'auto', // Will be determined by preset or user selection
+                qualityPreset: 'high',
+            },
+            id: 'video-gen-1',
+            inputs: ['cast-prompt-1'],
+            label: 'AI Video Generation',
+            type: 'video-generator',
+        },
+        // Node 3: Upscale Pass 1
+        {
+            config: {
+                denoise: 0.1,
+                method: 'ai-enhance',
+                preserveDetails: true,
+                scaleFactor: 2,
+            },
+            id: 'upscale-1',
+            inputs: ['video-gen-1'],
+            label: 'Upscale Pass 1',
+            type: 'video-upscale',
+        },
+        // Node 4: Upscale Pass 2 (Optional)
+        {
+            config: {
+                denoise: 0.05,
+                enabled: false, // Can be toggled by user
+                method: 'ai-enhance',
+                preserveDetails: true,
+                scaleFactor: 1.5,
+            },
+            id: 'upscale-2',
+            inputs: ['upscale-1'],
+            label: 'Upscale Pass 2 (Optional)',
+            type: 'video-upscale',
+        },
+        // Node 5: Color Grading
+        {
+            config: {
+                cameraProfile: '',
+                contrast: 1.0,
+                highlights: 0,
+                midtones: 0,
+                saturation: 1.0,
+                shadows: 0,
+                sourcePreset: 'cast-prompt-1', // Pulls config from CAST preset
+                temperature: 5600,
+            },
+            id: 'color-grade-1',
+            inputs: ['upscale-2'],
+            label: 'Color Grading',
+            type: 'color-grade',
+        },
+        // Node 6: Film Grain
+        {
+            config: {
+                colorGrain: false,
+                intensity: 0.0,
+                size: 'fine',
+                sourcePreset: 'cast-prompt-1', // Pulls config from CAST preset
+                stock: 'Digital Clean',
+            },
+            id: 'film-grain-1',
+            inputs: ['color-grade-1'],
+            label: 'Film Grain',
+            type: 'film-grain',
+        },
+        // Node 7: Lens Effects
+        {
+            config: {
+                barrelDistortion: {
+                    amount: 0,
+                    enabled: false,
+                },
+                bloom: {
+                    enabled: false,
+                    intensity: 0,
+                    threshold: 0,
+                },
+                chromaticAberration: {
+                    enabled: false,
+                    intensity: 0,
+                },
+                sourcePreset: 'cast-prompt-1', // Pulls config from CAST preset
+                vignette: {
+                    enabled: false,
+                    intensity: 0,
+                    softness: 0,
+                },
+            },
+            id: 'lens-effects-1',
+            inputs: ['film-grain-1'],
+            label: 'Lens Effects',
+            type: 'lens-effects',
+        },
+        // Node 8: Platform Export
+        {
+            config: {
+                formats: {
+                    instagram: {
+                        aspectRatio: '9:16',
+                        bitrate: '8000k',
+                        codec: 'h264',
+                        maxDuration: 60,
+                    },
+                    tiktok: {
+                        aspectRatio: '9:16',
+                        bitrate: '8000k',
+                        codec: 'h264',
+                        maxDuration: 60,
+                    },
+                    youtube: {
+                        aspectRatio: '16:9',
+                        bitrate: '12000k',
+                        codec: 'h264',
+                        maxDuration: null,
+                    },
+                },
+                platforms: ['instagram', 'tiktok', 'youtube'],
+                watermark: {
+                    enabled: false,
+                    opacity: 0.3,
+                    position: 'bottom-right',
+                },
+            },
+            id: 'platform-export-1',
+            inputs: ['lens-effects-1'],
+            label: 'Platform Export',
+            type: 'platform-export',
+        },
+    ],
+};
+/**
+ * Create a new workflow instance from the template with custom config
+ */
+export const createCinematicWorkflowInstance = (config) => {
+    const template = JSON.parse(JSON.stringify(CINEMATIC_VIDEO_TEMPLATE)); // Deep clone
+    // Apply CAST config overrides
+    if (config.castConfig) {
+        const castNode = template.nodes.find((n) => n.id === 'cast-prompt-1');
+        if (castNode) {
+            castNode.config = { ...castNode.config, ...config.castConfig };
+        }
+    }
+    // Apply video generation config overrides
+    if (config.videoConfig) {
+        const videoNode = template.nodes.find((n) => n.id === 'video-gen-1');
+        if (videoNode) {
+            videoNode.config = { ...videoNode.config, ...config.videoConfig };
+        }
+    }
+    // Enable/disable second upscale pass
+    if (config.enableSecondUpscale !== undefined) {
+        const upscale2Node = template.nodes.find((n) => n.id === 'upscale-2');
+        if (upscale2Node) {
+            upscale2Node.config.enabled = config.enableSecondUpscale;
+        }
+    }
+    // Configure export platforms
+    if (config.exportPlatforms) {
+        const exportNode = template.nodes.find((n) => n.id === 'platform-export-1');
+        if (exportNode) {
+            exportNode.config.platforms = config.exportPlatforms;
+        }
+    }
+    // Destructure to avoid overwriting custom id
+    const { id: _templateId, ...templateWithoutId } = template;
+    return {
+        ...templateWithoutId,
+        id: config.workflowId,
+        organizationId: config.organizationId,
+        userId: config.userId,
+    };
+};
+/**
+ * Get list of all available workflow templates
+ */
+export const getAvailableTemplates = () => {
+    return [CINEMATIC_VIDEO_TEMPLATE];
+};
+/**
+ * Get template by ID
+ */
+export const getTemplateById = (id) => {
+    const templates = getAvailableTemplates();
+    return templates.find((t) => t.id === id) || null;
+};

package/dist/workflow-engine/src/templates/cinematic-video.template.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cinematic-video.template.spec.d.ts.map

package/dist/workflow-engine/src/templates/cinematic-video.template.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cinematic-video.template.spec.d.ts","sourceRoot":"","sources":["../../../../src/templates/cinematic-video.template.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/templates/cinematic-video.template.spec.js

@@ -0,0 +1,361 @@
+import {
+  CINEMATIC_VIDEO_TEMPLATE,
+  createCinematicWorkflowInstance,
+  getAvailableTemplates,
+  getTemplateById,
+} from '@workflow-engine/templates/cinematic-video.template';
+import { describe, expect, it } from 'vitest';
+
+describe('CinematicVideoTemplate', () => {
+  describe('Template Structure', () => {
+    it('should have all required metadata', () => {
+      expect(CINEMATIC_VIDEO_TEMPLATE.id).toBe('cinematic-video-ugc');
+      expect(CINEMATIC_VIDEO_TEMPLATE.name).toBeTruthy();
+      expect(CINEMATIC_VIDEO_TEMPLATE.description).toBeTruthy();
+      expect(CINEMATIC_VIDEO_TEMPLATE.category).toBe('video-generation');
+      expect(CINEMATIC_VIDEO_TEMPLATE.metadata.version).toBeTruthy();
+      expect(CINEMATIC_VIDEO_TEMPLATE.metadata.tags.length).toBeGreaterThan(0);
+    });
+    it('should have correct number of nodes', () => {
+      expect(CINEMATIC_VIDEO_TEMPLATE.nodes).toHaveLength(8);
+    });
+    it('should have correct number of edges', () => {
+      expect(CINEMATIC_VIDEO_TEMPLATE.edges).toHaveLength(10);
+    });
+    it('should have all nodes with unique IDs', () => {
+      const nodeIds = CINEMATIC_VIDEO_TEMPLATE.nodes.map((n) => n.id);
+      const uniqueIds = new Set(nodeIds);
+      expect(uniqueIds.size).toBe(nodeIds.length);
+    });
+    it('should have all edges with unique IDs', () => {
+      const edgeIds = CINEMATIC_VIDEO_TEMPLATE.edges.map((e) => e.id);
+      const uniqueIds = new Set(edgeIds);
+      expect(uniqueIds.size).toBe(edgeIds.length);
+    });
+  });
+  describe('Workflow Nodes', () => {
+    it('should have CAST prompt generator as first node', () => {
+      const castNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'cast-prompt-1',
+      );
+      expect(castNode).toBeDefined();
+      expect(castNode?.type).toBe('cast-prompt-generator');
+      expect(castNode?.config.presetId).toBe('hollywood_blockbuster');
+    });
+    it('should have video generation node', () => {
+      const videoNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'video-gen-1',
+      );
+      expect(videoNode).toBeDefined();
+      expect(videoNode?.type).toBe('video-generator');
+      expect(videoNode?.inputs).toContain('cast-prompt-1');
+    });
+    it('should have two upscale nodes', () => {
+      const upscale1 = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'upscale-1',
+      );
+      const upscale2 = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'upscale-2',
+      );
+      expect(upscale1).toBeDefined();
+      expect(upscale2).toBeDefined();
+      expect(upscale1?.type).toBe('video-upscale');
+      expect(upscale2?.type).toBe('video-upscale');
+    });
+    it('should have second upscale as optional', () => {
+      const upscale2 = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'upscale-2',
+      );
+      expect(upscale2?.config.enabled).toBe(false);
+    });
+    it('should have color grading node', () => {
+      const colorNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'color-grade-1',
+      );
+      expect(colorNode).toBeDefined();
+      expect(colorNode?.type).toBe('color-grade');
+      expect(colorNode?.config.sourcePreset).toBe('cast-prompt-1');
+    });
+    it('should have film grain node', () => {
+      const grainNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'film-grain-1',
+      );
+      expect(grainNode).toBeDefined();
+      expect(grainNode?.type).toBe('film-grain');
+      expect(grainNode?.config.sourcePreset).toBe('cast-prompt-1');
+    });
+    it('should have lens effects node', () => {
+      const lensNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'lens-effects-1',
+      );
+      expect(lensNode).toBeDefined();
+      expect(lensNode?.type).toBe('lens-effects');
+      expect(lensNode?.config.sourcePreset).toBe('cast-prompt-1');
+    });
+    it('should have platform export node', () => {
+      const exportNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      expect(exportNode).toBeDefined();
+      expect(exportNode?.type).toBe('platform-export');
+      expect(exportNode?.config.platforms).toContain('instagram');
+      expect(exportNode?.config.platforms).toContain('tiktok');
+      expect(exportNode?.config.platforms).toContain('youtube');
+    });
+  });
+  describe('Workflow Edges', () => {
+    it('should connect CAST prompt to video generation', () => {
+      const edge = CINEMATIC_VIDEO_TEMPLATE.edges.find(
+        (e) => e.source === 'cast-prompt-1' && e.target === 'video-gen-1',
+      );
+      expect(edge).toBeDefined();
+    });
+    it('should create linear video processing pipeline', () => {
+      const pipelineEdges = [
+        { source: 'video-gen-1', target: 'upscale-1' },
+        { source: 'upscale-1', target: 'upscale-2' },
+        { source: 'upscale-2', target: 'color-grade-1' },
+        { source: 'color-grade-1', target: 'film-grain-1' },
+        { source: 'film-grain-1', target: 'lens-effects-1' },
+        { source: 'lens-effects-1', target: 'platform-export-1' },
+      ];
+      pipelineEdges.forEach(({ source, target }) => {
+        const edge = CINEMATIC_VIDEO_TEMPLATE.edges.find(
+          (e) => e.source === source && e.target === target,
+        );
+        expect(edge).toBeDefined();
+      });
+    });
+    it('should connect CAST preset to post-processing nodes', () => {
+      const presetConnections = [
+        { source: 'cast-prompt-1', target: 'color-grade-1' },
+        { source: 'cast-prompt-1', target: 'film-grain-1' },
+        { source: 'cast-prompt-1', target: 'lens-effects-1' },
+      ];
+      presetConnections.forEach(({ source, target }) => {
+        const edge = CINEMATIC_VIDEO_TEMPLATE.edges.find(
+          (e) => e.source === source && e.target === target,
+        );
+        expect(edge).toBeDefined();
+      });
+    });
+    it('should have correct handles for preset config edges', () => {
+      const presetEdges = CINEMATIC_VIDEO_TEMPLATE.edges.filter(
+        (e) => e.source === 'cast-prompt-1' && e.sourceHandle === 'preset',
+      );
+      expect(presetEdges.length).toBe(3); // color-grade, film-grain, lens-effects
+    });
+  });
+  describe('createCinematicWorkflowInstance', () => {
+    it('should create workflow instance with required IDs', () => {
+      const instance = createCinematicWorkflowInstance({
+        organizationId: 'org-456',
+        userId: 'user-789',
+        workflowId: 'wf-123',
+      });
+      expect(instance.id).toBe('wf-123');
+      expect(instance.organizationId).toBe('org-456');
+      expect(instance.userId).toBe('user-789');
+    });
+    it('should apply CAST config overrides', () => {
+      const instance = createCinematicWorkflowInstance({
+        castConfig: {
+          action: 'custom action',
+          cameraMovement: 'handheld',
+          presetId: 'indie_film',
+        },
+        organizationId: 'org-456',
+        userId: 'user-789',
+        workflowId: 'wf-123',
+      });
+      const castNode = instance.nodes.find((n) => n.id === 'cast-prompt-1');
+      expect(castNode?.config.presetId).toBe('indie_film');
+      expect(castNode?.config.cameraMovement).toBe('handheld');
+      expect(castNode?.config.action).toBe('custom action');
+    });
+    it('should apply video config overrides', () => {
+      const instance = createCinematicWorkflowInstance({
+        organizationId: 'org-456',
+        userId: 'user-789',
+        videoConfig: {
+          aspectRatio: '9:16',
+          duration: 10,
+          fps: 30,
+        },
+        workflowId: 'wf-123',
+      });
+      const videoNode = instance.nodes.find((n) => n.id === 'video-gen-1');
+      expect(videoNode?.config.duration).toBe(10);
+      expect(videoNode?.config.aspectRatio).toBe('9:16');
+      expect(videoNode?.config.fps).toBe(30);
+    });
+    it('should enable second upscale when requested', () => {
+      const instance = createCinematicWorkflowInstance({
+        enableSecondUpscale: true,
+        organizationId: 'org-456',
+        userId: 'user-789',
+        workflowId: 'wf-123',
+      });
+      const upscale2Node = instance.nodes.find((n) => n.id === 'upscale-2');
+      expect(upscale2Node?.config.enabled).toBe(true);
+    });
+    it('should configure export platforms', () => {
+      const instance = createCinematicWorkflowInstance({
+        exportPlatforms: ['instagram', 'youtube'],
+        organizationId: 'org-456',
+        userId: 'user-789',
+        workflowId: 'wf-123',
+      });
+      const exportNode = instance.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      expect(exportNode?.config.platforms).toEqual(['instagram', 'youtube']);
+    });
+    it('should not modify original template', () => {
+      const originalPreset = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'cast-prompt-1',
+      )?.config.presetId;
+      createCinematicWorkflowInstance({
+        castConfig: { presetId: 'vintage_35mm' },
+        organizationId: 'org-456',
+        userId: 'user-789',
+        workflowId: 'wf-123',
+      });
+      const unchangedPreset = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'cast-prompt-1',
+      )?.config.presetId;
+      expect(unchangedPreset).toBe(originalPreset);
+    });
+  });
+  describe('getAvailableTemplates', () => {
+    it('should return array of templates', () => {
+      const templates = getAvailableTemplates();
+      expect(Array.isArray(templates)).toBe(true);
+      expect(templates.length).toBeGreaterThan(0);
+    });
+    it('should include cinematic video template', () => {
+      const templates = getAvailableTemplates();
+      const cinematicTemplate = templates.find(
+        (t) => t.id === 'cinematic-video-ugc',
+      );
+      expect(cinematicTemplate).toBeDefined();
+    });
+  });
+  describe('getTemplateById', () => {
+    it('should return template when valid ID is provided', () => {
+      const template = getTemplateById('cinematic-video-ugc');
+      expect(template).toBeDefined();
+      expect(template?.id).toBe('cinematic-video-ugc');
+    });
+    it('should return null when invalid ID is provided', () => {
+      const template = getTemplateById('nonexistent-template');
+      expect(template).toBeNull();
+    });
+  });
+  describe('Platform Export Configuration', () => {
+    it('should have correct Instagram format', () => {
+      const exportNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      const config = exportNode?.config;
+      const igFormat = config?.formats?.instagram;
+      expect(igFormat).toBeDefined();
+      expect(igFormat?.aspectRatio).toBe('9:16');
+      expect(igFormat?.maxDuration).toBe(60);
+      expect(igFormat?.codec).toBe('h264');
+    });
+    it('should have correct TikTok format', () => {
+      const exportNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      const config = exportNode?.config;
+      const tiktokFormat = config?.formats?.tiktok;
+      expect(tiktokFormat).toBeDefined();
+      expect(tiktokFormat?.aspectRatio).toBe('9:16');
+      expect(tiktokFormat?.maxDuration).toBe(60);
+    });
+    it('should have correct YouTube format', () => {
+      const exportNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      const config = exportNode?.config;
+      const ytFormat = config?.formats?.youtube;
+      expect(ytFormat).toBeDefined();
+      expect(ytFormat?.aspectRatio).toBe('16:9');
+      expect(ytFormat?.maxDuration).toBeNull();
+    });
+    it('should have watermark disabled by default', () => {
+      const exportNode = CINEMATIC_VIDEO_TEMPLATE.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      const config = exportNode?.config;
+      expect(config?.watermark?.enabled).toBe(false);
+    });
+  });
+  describe('Node Dependencies', () => {
+    it('should have correct input dependencies for each node', () => {
+      const nodeInputs = [
+        { expectedInputs: [], id: 'cast-prompt-1' },
+        { expectedInputs: ['cast-prompt-1'], id: 'video-gen-1' },
+        { expectedInputs: ['video-gen-1'], id: 'upscale-1' },
+        { expectedInputs: ['upscale-1'], id: 'upscale-2' },
+        { expectedInputs: ['upscale-2'], id: 'color-grade-1' },
+        { expectedInputs: ['color-grade-1'], id: 'film-grain-1' },
+        { expectedInputs: ['film-grain-1'], id: 'lens-effects-1' },
+        { expectedInputs: ['lens-effects-1'], id: 'platform-export-1' },
+      ];
+      nodeInputs.forEach(({ id, expectedInputs }) => {
+        const node = CINEMATIC_VIDEO_TEMPLATE.nodes.find((n) => n.id === id);
+        expect(node?.inputs).toEqual(expectedInputs);
+      });
+    });
+  });
+  describe('Real-world Workflow Scenarios', () => {
+    it('should create Instagram-optimized workflow', () => {
+      const instance = createCinematicWorkflowInstance({
+        castConfig: {
+          cameraMovement: 'tracking',
+          presetId: 'social_media_cinematic',
+        },
+        exportPlatforms: ['instagram'],
+        organizationId: 'org-1',
+        userId: 'user-1',
+        videoConfig: {
+          aspectRatio: '9:16',
+          duration: 15,
+        },
+        workflowId: 'ig-wf-1',
+      });
+      const castNode = instance.nodes.find((n) => n.id === 'cast-prompt-1');
+      expect(castNode?.config.presetId).toBe('social_media_cinematic');
+      const videoNode = instance.nodes.find((n) => n.id === 'video-gen-1');
+      expect(videoNode?.config.aspectRatio).toBe('9:16');
+      const exportNode = instance.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      expect(exportNode?.config.platforms).toEqual(['instagram']);
+    });
+    it('should create high-quality multi-platform workflow', () => {
+      const instance = createCinematicWorkflowInstance({
+        castConfig: {
+          presetId: 'hollywood_blockbuster',
+        },
+        enableSecondUpscale: true,
+        exportPlatforms: ['instagram', 'tiktok', 'youtube'],
+        organizationId: 'org-1',
+        userId: 'user-1',
+        videoConfig: {
+          duration: 30,
+          fps: 30,
+        },
+        workflowId: 'multi-wf-1',
+      });
+      const upscale2 = instance.nodes.find((n) => n.id === 'upscale-2');
+      expect(upscale2?.config.enabled).toBe(true);
+      const exportNode = instance.nodes.find(
+        (n) => n.id === 'platform-export-1',
+      );
+      expect(exportNode?.config.platforms).toHaveLength(3);
+    });
+  });
+});

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

@@ -0,0 +1,3 @@
+export type { WorkflowTemplate } from '@workflow-engine/templates/cinematic-video.template';
+export { CINEMATIC_VIDEO_TEMPLATE, createCinematicWorkflowInstance, getAvailableTemplates, getTemplateById, } from '@workflow-engine/templates/cinematic-video.template';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,qBAAqB,EACrB,eAAe,GAChB,MAAM,qDAAqD,CAAC"}

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

@@ -0,0 +1 @@
+export { CINEMATIC_VIDEO_TEMPLATE, createCinematicWorkflowInstance, getAvailableTemplates, getTemplateById, } from '@workflow-engine/templates/cinematic-video.template';