@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/presets/cinematic-presets.js

@@ -0,0 +1,185 @@
+export const CINEMATIC_PRESETS = {
+    commercial_clean: {
+        cameraPrompt: 'Sony Venice 2 with Sony CineAlta 50mm T2.0, pristine detail, balanced color science, soft diffusion, studio lighting',
+        colorGrade: {
+            cameraProfile: 'Sony S-Log3',
+            contrast: 1.08,
+            highlights: 0,
+            midtones: 0,
+            saturation: 1.0,
+            shadows: 0,
+            temperature: 5500,
+        },
+        description: 'Pristine, polished commercial look with balanced color and soft diffusion',
+        filmGrain: {
+            colorGrain: false,
+            intensity: 0.0,
+            size: 'fine',
+            stock: 'Digital Clean',
+        },
+        id: 'commercial_clean',
+        lensEffects: {
+            barrelDistortion: { amount: 0, enabled: false },
+            bloom: { enabled: true, intensity: 0.2, threshold: 0.95 },
+            chromaticAberration: { enabled: false, intensity: 0 },
+            vignette: { enabled: true, intensity: 0.15, softness: 0.9 },
+        },
+        name: 'Commercial Clean',
+    },
+    documentary_raw: {
+        cameraPrompt: 'Filmed on RED V-Raptor XL with Zeiss Supreme Prime 35mm, handheld stabilized, natural lighting, high detail retention in shadows',
+        colorGrade: {
+            cameraProfile: 'RED Log3G10',
+            contrast: 1.05,
+            highlights: -10,
+            midtones: -5,
+            saturation: 0.85,
+            shadows: 10,
+            temperature: 5800,
+        },
+        description: 'Authentic documentary style with RED camera, high detail and natural lighting',
+        filmGrain: {
+            colorGrain: false,
+            intensity: 0.05,
+            size: 'medium',
+            stock: 'Digital Clean',
+        },
+        id: 'documentary_raw',
+        lensEffects: {
+            barrelDistortion: { amount: 0.05, enabled: true },
+            bloom: { enabled: false, intensity: 0, threshold: 0 },
+            chromaticAberration: { enabled: true, intensity: 0.1 },
+            vignette: { enabled: false, intensity: 0, softness: 0 },
+        },
+        name: 'Documentary Raw',
+    },
+    hollywood_blockbuster: {
+        cameraPrompt: 'Shot on ARRI Alexa Mini LF with Cooke S7/i 50mm T2.0, shallow depth of field, natural skin tones, wide dynamic range, subtle film grain',
+        colorGrade: {
+            cameraProfile: 'ARRI LogC3',
+            contrast: 1.15,
+            highlights: 5,
+            midtones: 0,
+            saturation: 0.95,
+            shadows: -5,
+            temperature: 5600,
+        },
+        description: 'Premium cinematic look with ARRI Alexa, perfect for high-end commercial content',
+        filmGrain: {
+            colorGrain: false,
+            intensity: 0.15,
+            size: 'fine',
+            stock: 'Kodak Vision3 250D',
+        },
+        id: 'hollywood_blockbuster',
+        lensEffects: {
+            barrelDistortion: { amount: 0, enabled: false },
+            bloom: { enabled: true, intensity: 0.3, threshold: 0.9 },
+            chromaticAberration: { enabled: false, intensity: 0 },
+            vignette: { enabled: true, intensity: 0.2, softness: 0.7 },
+        },
+        name: 'Hollywood Blockbuster',
+    },
+    indie_film: {
+        cameraPrompt: 'Shot on Blackmagic Pocket 6K Pro with Rokinon 24mm T1.5, anamorphic lens flare, desaturated color palette, visible film grain, moody atmosphere',
+        colorGrade: {
+            cameraProfile: 'BMD Film Gen 5',
+            contrast: 1.1,
+            highlights: -5,
+            midtones: -10,
+            saturation: 0.75,
+            shadows: 15,
+            temperature: 4800,
+        },
+        description: 'Moody, atmospheric indie aesthetic with anamorphic characteristics',
+        filmGrain: {
+            colorGrain: true,
+            intensity: 0.35,
+            size: 'medium',
+            stock: 'Kodak Vision3 500T',
+        },
+        id: 'indie_film',
+        lensEffects: {
+            barrelDistortion: { amount: 0.08, enabled: true },
+            bloom: { enabled: true, intensity: 0.5, threshold: 0.75 },
+            chromaticAberration: { enabled: true, intensity: 0.25 },
+            vignette: { enabled: true, intensity: 0.45, softness: 0.6 },
+        },
+        name: 'Indie Film',
+    },
+    social_media_cinematic: {
+        cameraPrompt: 'Canon C70 with Sigma 18-35mm f/1.8 Art lens, vibrant colors, punchy contrast, smooth bokeh in background',
+        colorGrade: {
+            cameraProfile: 'Canon C-Log2',
+            contrast: 1.25,
+            highlights: 10,
+            midtones: 5,
+            saturation: 1.15,
+            shadows: -15,
+            temperature: 5200,
+        },
+        description: 'Punchy, vibrant look optimized for Instagram and TikTok engagement',
+        filmGrain: {
+            colorGrain: true,
+            intensity: 0.08,
+            size: 'fine',
+            stock: 'Digital Clean',
+        },
+        id: 'social_media_cinematic',
+        lensEffects: {
+            barrelDistortion: { amount: 0, enabled: false },
+            bloom: { enabled: true, intensity: 0.4, threshold: 0.85 },
+            chromaticAberration: { enabled: false, intensity: 0 },
+            vignette: { enabled: true, intensity: 0.35, softness: 0.5 },
+        },
+        name: 'Social Media Cinematic',
+    },
+    vintage_35mm: {
+        cameraPrompt: 'Filmed on 35mm Kodak Vision3 500T film stock, Panavision Primo 40mm lens, heavy grain structure, warm color shift, lifted blacks, halation on highlights',
+        colorGrade: {
+            cameraProfile: 'Film Print Emulation',
+            contrast: 0.95,
+            highlights: 15,
+            midtones: 10,
+            saturation: 1.05,
+            shadows: 25,
+            temperature: 4500,
+        },
+        description: 'Classic film stock emulation with heavy grain and warm color shift',
+        filmGrain: {
+            colorGrain: true,
+            intensity: 0.55,
+            size: 'large',
+            stock: 'Kodak Vision3 500T',
+        },
+        id: 'vintage_35mm',
+        lensEffects: {
+            barrelDistortion: { amount: 0.12, enabled: true },
+            bloom: { enabled: true, intensity: 0.6, threshold: 0.7 },
+            chromaticAberration: { enabled: true, intensity: 0.15 },
+            vignette: { enabled: true, intensity: 0.3, softness: 0.8 },
+        },
+        name: 'Vintage 35mm Film',
+    },
+};
+export const getPresetById = (id) => {
+    return CINEMATIC_PRESETS[id] || null;
+};
+export const getAllPresets = () => {
+    return Object.values(CINEMATIC_PRESETS);
+};
+export const getPresetsByCategory = (category) => {
+    const categoryMap = {
+        artistic: ['indie_film', 'vintage_35mm'],
+        professional: [
+            'hollywood_blockbuster',
+            'documentary_raw',
+            'commercial_clean',
+        ],
+        social: ['social_media_cinematic'],
+    };
+    const presetIds = categoryMap[category] || [];
+    return presetIds
+        .map((id) => CINEMATIC_PRESETS[id])
+        .filter((preset) => preset !== undefined);
+};

package/dist/workflow-engine/src/presets/cinematic-presets.spec.d.ts

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

package/dist/workflow-engine/src/presets/cinematic-presets.spec.d.ts.map

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

package/dist/workflow-engine/src/presets/cinematic-presets.spec.js

@@ -0,0 +1,225 @@
+import {
+  CINEMATIC_PRESETS,
+  getAllPresets,
+  getPresetById,
+  getPresetsByCategory,
+} from '@workflow-engine/presets/cinematic-presets';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+describe('CinematicPresets', () => {
+  describe('Preset Structure', () => {
+    it('should have exactly 6 presets defined', () => {
+      const presets = getAllPresets();
+      expect(presets).toHaveLength(6);
+    });
+    it('should have all required preset IDs', () => {
+      const expectedIds = [
+        'hollywood_blockbuster',
+        'documentary_raw',
+        'social_media_cinematic',
+        'indie_film',
+        'vintage_35mm',
+        'commercial_clean',
+      ];
+      expectedIds.forEach((id) => {
+        expect(CINEMATIC_PRESETS[id]).toBeDefined();
+      });
+    });
+    it('should have valid structure for each preset', () => {
+      const presets = getAllPresets();
+      presets.forEach((preset) => {
+        // Check top-level properties
+        expect(preset.id).toBeTruthy();
+        expect(preset.name).toBeTruthy();
+        expect(preset.description).toBeTruthy();
+        expect(preset.cameraPrompt).toBeTruthy();
+        // Check colorGrade
+        expect(preset.colorGrade).toBeDefined();
+        expect(preset.colorGrade.cameraProfile).toBeTruthy();
+        expect(typeof preset.colorGrade.contrast).toBe('number');
+        expect(typeof preset.colorGrade.saturation).toBe('number');
+        expect(typeof preset.colorGrade.temperature).toBe('number');
+        expect(typeof preset.colorGrade.shadows).toBe('number');
+        expect(typeof preset.colorGrade.midtones).toBe('number');
+        expect(typeof preset.colorGrade.highlights).toBe('number');
+        // Check filmGrain
+        expect(preset.filmGrain).toBeDefined();
+        expect(preset.filmGrain.stock).toBeTruthy();
+        expect(typeof preset.filmGrain.intensity).toBe('number');
+        expect(preset.filmGrain.size).toBeTruthy();
+        expect(typeof preset.filmGrain.colorGrain).toBe('boolean');
+        // Check lensEffects
+        expect(preset.lensEffects).toBeDefined();
+        expect(preset.lensEffects.vignette).toBeDefined();
+        expect(preset.lensEffects.chromaticAberration).toBeDefined();
+        expect(preset.lensEffects.barrelDistortion).toBeDefined();
+        expect(preset.lensEffects.bloom).toBeDefined();
+      });
+    });
+  });
+  describe('Hollywood Blockbuster Preset', () => {
+    let preset;
+    beforeEach(() => {
+      preset = CINEMATIC_PRESETS.hollywood_blockbuster;
+    });
+    it('should have correct camera prompt', () => {
+      expect(preset.cameraPrompt).toContain('ARRI Alexa Mini LF');
+      expect(preset.cameraPrompt).toContain('Cooke S7/i 50mm T2.0');
+    });
+    it('should have ARRI LogC3 color profile', () => {
+      expect(preset.colorGrade.cameraProfile).toBe('ARRI LogC3');
+    });
+    it('should have subtle film grain', () => {
+      expect(preset.filmGrain.intensity).toBeLessThan(0.3);
+      expect(preset.filmGrain.colorGrain).toBe(false);
+    });
+    it('should have vignette enabled but minimal chromatic aberration', () => {
+      expect(preset.lensEffects.vignette.enabled).toBe(true);
+      expect(preset.lensEffects.chromaticAberration.enabled).toBe(false);
+    });
+  });
+  describe('Documentary Raw Preset', () => {
+    let preset;
+    beforeEach(() => {
+      preset = CINEMATIC_PRESETS.documentary_raw;
+    });
+    it('should have RED camera specs', () => {
+      expect(preset.cameraPrompt).toContain('RED V-Raptor XL');
+    });
+    it('should have low saturation for natural look', () => {
+      expect(preset.colorGrade.saturation).toBeLessThan(1.0);
+    });
+    it('should have minimal film grain', () => {
+      expect(preset.filmGrain.intensity).toBeLessThan(0.1);
+    });
+    it('should have some lens imperfections for realism', () => {
+      expect(preset.lensEffects.chromaticAberration.enabled).toBe(true);
+      expect(preset.lensEffects.barrelDistortion.enabled).toBe(true);
+    });
+  });
+  describe('Social Media Cinematic Preset', () => {
+    let preset;
+    beforeEach(() => {
+      preset = CINEMATIC_PRESETS.social_media_cinematic;
+    });
+    it('should have vibrant, punchy settings', () => {
+      expect(preset.colorGrade.contrast).toBeGreaterThan(1.2);
+      expect(preset.colorGrade.saturation).toBeGreaterThan(1.1);
+    });
+    it('should have strong vignette for focus', () => {
+      expect(preset.lensEffects.vignette.enabled).toBe(true);
+      expect(preset.lensEffects.vignette.intensity).toBeGreaterThan(0.3);
+    });
+    it('should have color grain for digital warmth', () => {
+      expect(preset.filmGrain.colorGrain).toBe(true);
+    });
+  });
+  describe('Indie Film Preset', () => {
+    let preset;
+    beforeEach(() => {
+      preset = CINEMATIC_PRESETS.indie_film;
+    });
+    it('should have desaturated look', () => {
+      expect(preset.colorGrade.saturation).toBeLessThan(0.8);
+    });
+    it('should have visible film grain', () => {
+      expect(preset.filmGrain.intensity).toBeGreaterThan(0.3);
+    });
+    it('should have anamorphic characteristics', () => {
+      expect(preset.cameraPrompt).toContain('anamorphic');
+      expect(preset.lensEffects.chromaticAberration.enabled).toBe(true);
+    });
+  });
+  describe('Vintage 35mm Preset', () => {
+    let preset;
+    beforeEach(() => {
+      preset = CINEMATIC_PRESETS.vintage_35mm;
+    });
+    it('should have heavy grain', () => {
+      expect(preset.filmGrain.intensity).toBeGreaterThan(0.5);
+      expect(preset.filmGrain.size).toBe('large');
+    });
+    it('should have warm color shift', () => {
+      expect(preset.colorGrade.temperature).toBeLessThan(5000);
+    });
+    it('should have lifted blacks', () => {
+      expect(preset.colorGrade.shadows).toBeGreaterThan(20);
+    });
+    it('should have halation characteristics', () => {
+      expect(preset.cameraPrompt).toContain('halation');
+      expect(preset.lensEffects.bloom.enabled).toBe(true);
+    });
+  });
+  describe('Commercial Clean Preset', () => {
+    let preset;
+    beforeEach(() => {
+      preset = CINEMATIC_PRESETS.commercial_clean;
+    });
+    it('should have no film grain', () => {
+      expect(preset.filmGrain.intensity).toBe(0);
+    });
+    it('should have balanced color grading', () => {
+      expect(preset.colorGrade.saturation).toBe(1.0);
+      expect(preset.colorGrade.shadows).toBe(0);
+      expect(preset.colorGrade.midtones).toBe(0);
+      expect(preset.colorGrade.highlights).toBe(0);
+    });
+    it('should have minimal lens effects', () => {
+      expect(preset.lensEffects.chromaticAberration.enabled).toBe(false);
+      expect(preset.lensEffects.barrelDistortion.enabled).toBe(false);
+    });
+  });
+  describe('getPresetById', () => {
+    it('should return preset when valid ID is provided', () => {
+      const preset = getPresetById('hollywood_blockbuster');
+      expect(preset).toBeDefined();
+      expect(preset?.id).toBe('hollywood_blockbuster');
+    });
+    it('should return null when invalid ID is provided', () => {
+      const preset = getPresetById('nonexistent_preset');
+      expect(preset).toBeNull();
+    });
+  });
+  describe('getAllPresets', () => {
+    it('should return array of all presets', () => {
+      const presets = getAllPresets();
+      expect(Array.isArray(presets)).toBe(true);
+      expect(presets.length).toBe(6);
+    });
+    it('should return presets with unique IDs', () => {
+      const presets = getAllPresets();
+      const ids = presets.map((p) => p.id);
+      const uniqueIds = new Set(ids);
+      expect(uniqueIds.size).toBe(ids.length);
+    });
+  });
+  describe('getPresetsByCategory', () => {
+    it('should return professional presets', () => {
+      const presets = getPresetsByCategory('professional');
+      expect(presets.length).toBe(3);
+      expect(presets.map((p) => p.id)).toEqual(
+        expect.arrayContaining([
+          'hollywood_blockbuster',
+          'documentary_raw',
+          'commercial_clean',
+        ]),
+      );
+    });
+    it('should return social presets', () => {
+      const presets = getPresetsByCategory('social');
+      expect(presets.length).toBe(1);
+      expect(presets[0].id).toBe('social_media_cinematic');
+    });
+    it('should return artistic presets', () => {
+      const presets = getPresetsByCategory('artistic');
+      expect(presets.length).toBe(2);
+      expect(presets.map((p) => p.id)).toEqual(
+        expect.arrayContaining(['indie_film', 'vintage_35mm']),
+      );
+    });
+    it('should return empty array for invalid category', () => {
+      const presets = getPresetsByCategory('invalid');
+      expect(presets).toEqual([]);
+    });
+  });
+});

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

@@ -0,0 +1,3 @@
+export type { CinematicPreset } from '@workflow-engine/presets/cinematic-presets';
+export { CINEMATIC_PRESETS, getAllPresets, getPresetById, getPresetsByCategory, } from '@workflow-engine/presets/cinematic-presets';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/presets/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,oBAAoB,GACrB,MAAM,4CAA4C,CAAC"}

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

@@ -0,0 +1 @@
+export { CINEMATIC_PRESETS, getAllPresets, getPresetById, getPresetsByCategory, } from '@workflow-engine/presets/cinematic-presets';

package/dist/workflow-engine/src/services/cast-prompt.service.d.ts

@@ -0,0 +1,71 @@
+import type { CinematicPreset } from '@workflow-engine/presets/cinematic-presets';
+export type CameraMovement = 'dolly' | 'tracking' | 'static' | 'crane' | 'aerial' | 'handheld' | 'steadicam';
+export interface CASTInput {
+    presetId: string;
+    cameraMovement: CameraMovement;
+    action: string;
+    subject: string;
+    lighting: string;
+    colorPalette: string;
+    mood: string;
+}
+export interface CASTOutput {
+    prompt: string;
+    preset: CinematicPreset;
+    metadata: {
+        wordCount: number;
+        cameraMovement: string;
+    };
+}
+/**
+ * Generate a CAST-structured prompt for cinematic video generation
+ */
+export declare const generateCASTPrompt: (input: CASTInput) => CASTOutput;
+/**
+ * Validate CAST input fields
+ */
+export declare const validateCASTInput: (input: Partial<CASTInput>) => {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Extract post-processing configuration from preset
+ */
+export declare const extractPostProcessingConfig: (preset: CinematicPreset) => {
+    colorGrade: {
+        cameraProfile: string;
+        contrast: number;
+        saturation: number;
+        temperature: number;
+        shadows: number;
+        midtones: number;
+        highlights: number;
+    };
+    filmGrain: {
+        stock: string;
+        intensity: number;
+        size: string;
+        colorGrain: boolean;
+    };
+    lensEffects: {
+        vignette: {
+            enabled: boolean;
+            intensity: number;
+            softness: number;
+        };
+        chromaticAberration: {
+            enabled: boolean;
+            intensity: number;
+        };
+        barrelDistortion: {
+            enabled: boolean;
+            amount: number;
+        };
+        bloom: {
+            enabled: boolean;
+            threshold: number;
+            intensity: number;
+        };
+    };
+};
+//# sourceMappingURL=cast-prompt.service.d.ts.map

package/dist/workflow-engine/src/services/cast-prompt.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-prompt.service.d.ts","sourceRoot":"","sources":["../../../../src/services/cast-prompt.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAGlF,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,UAAU,GACV,WAAW,CAAC;AAEhB,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,cAAc,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AA+CD;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,SAAS,KAAG,UAsDrD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,OAAO,CAAC,SAAS,CAAC,KACxB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CA0CpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlE,CAAC"}

package/dist/workflow-engine/src/services/cast-prompt.service.js

@@ -0,0 +1,138 @@
+import { getPresetById } from '@workflow-engine/presets/cinematic-presets';
+const CAMERA_MOVEMENT_DESCRIPTIONS = {
+    aerial: 'aerial drone establishing shot',
+    crane: 'sweeping crane movement',
+    dolly: 'smooth dolly shot pushing in',
+    handheld: 'dynamic handheld camera movement',
+    static: 'locked-off static composition',
+    steadicam: 'fluid steadicam glide',
+    tracking: 'tracking shot following the subject',
+};
+/**
+ * Count words in a string
+ */
+const countWords = (text) => {
+    return text.trim().split(/\s+/).length;
+};
+/**
+ * Truncate text to a maximum word count while preserving sentence structure
+ */
+const truncateToWordLimit = (text, maxWords) => {
+    const words = text.trim().split(/\s+/);
+    if (words.length <= maxWords) {
+        return text;
+    }
+    // Try to end at a sentence boundary
+    const truncated = words.slice(0, maxWords).join(' ');
+    const lastPeriod = truncated.lastIndexOf('.');
+    const lastComma = truncated.lastIndexOf(',');
+    // If we can end at a period, do that
+    if (lastPeriod > truncated.length * 0.7) {
+        return truncated.slice(0, lastPeriod + 1);
+    }
+    // Otherwise, if we can end at a comma, do that
+    if (lastComma > truncated.length * 0.8) {
+        return truncated.slice(0, lastComma);
+    }
+    // Last resort: just truncate at word boundary
+    return truncated;
+};
+/**
+ * Generate a CAST-structured prompt for cinematic video generation
+ */
+export const generateCASTPrompt = (input) => {
+    // Validate preset exists
+    const preset = getPresetById(input.presetId);
+    if (!preset) {
+        throw new Error(`Preset not found: ${input.presetId}`);
+    }
+    // Validate required fields
+    if (!input.action?.trim()) {
+        throw new Error('Action is required');
+    }
+    if (!input.subject?.trim()) {
+        throw new Error('Subject is required');
+    }
+    if (!input.lighting?.trim()) {
+        throw new Error('Lighting is required');
+    }
+    if (!input.colorPalette?.trim()) {
+        throw new Error('Color palette is required');
+    }
+    if (!input.mood?.trim()) {
+        throw new Error('Mood is required');
+    }
+    // Build CAST prompt structure
+    const cameraMovementDesc = CAMERA_MOVEMENT_DESCRIPTIONS[input.cameraMovement];
+    // [Camera] - preset specs + movement
+    const cameraPart = `${preset.cameraPrompt}, ${cameraMovementDesc}`;
+    // [Action] - primary action
+    const actionPart = input.action.trim();
+    // [Subject] - detailed subject description
+    const subjectPart = input.subject.trim();
+    // [Tone] - lighting + color palette + mood
+    const tonePart = `${input.lighting}, ${input.colorPalette}, ${input.mood}`;
+    // Combine all parts
+    const fullPrompt = `${cameraPart}. ${actionPart}. ${subjectPart}. ${tonePart}.`;
+    // Enforce 150-word limit
+    const finalPrompt = truncateToWordLimit(fullPrompt, 150);
+    const wordCount = countWords(finalPrompt);
+    return {
+        metadata: {
+            cameraMovement: input.cameraMovement,
+            wordCount,
+        },
+        preset,
+        prompt: finalPrompt,
+    };
+};
+/**
+ * Validate CAST input fields
+ */
+export const validateCASTInput = (input) => {
+    const errors = [];
+    if (!input.presetId) {
+        errors.push('Preset ID is required');
+    }
+    else {
+        const preset = getPresetById(input.presetId);
+        if (!preset) {
+            errors.push(`Invalid preset ID: ${input.presetId}`);
+        }
+    }
+    if (!input.cameraMovement) {
+        errors.push('Camera movement is required');
+    }
+    else if (!CAMERA_MOVEMENT_DESCRIPTIONS[input.cameraMovement]) {
+        errors.push(`Invalid camera movement: ${input.cameraMovement}`);
+    }
+    if (!input.action?.trim()) {
+        errors.push('Action is required');
+    }
+    if (!input.subject?.trim()) {
+        errors.push('Subject is required');
+    }
+    if (!input.lighting?.trim()) {
+        errors.push('Lighting is required');
+    }
+    if (!input.colorPalette?.trim()) {
+        errors.push('Color palette is required');
+    }
+    if (!input.mood?.trim()) {
+        errors.push('Mood is required');
+    }
+    return {
+        errors,
+        valid: errors.length === 0,
+    };
+};
+/**
+ * Extract post-processing configuration from preset
+ */
+export const extractPostProcessingConfig = (preset) => {
+    return {
+        colorGrade: preset.colorGrade,
+        filmGrain: preset.filmGrain,
+        lensEffects: preset.lensEffects,
+    };
+};

package/dist/workflow-engine/src/services/cast-prompt.service.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cast-prompt.service.spec.d.ts.map

package/dist/workflow-engine/src/services/cast-prompt.service.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-prompt.service.spec.d.ts","sourceRoot":"","sources":["../../../../src/services/cast-prompt.service.spec.ts"],"names":[],"mappings":""}