@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/executors/saas/engagement-trigger-executor.js

@@ -0,0 +1,93 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+/**
+ * Engagement Trigger Executor
+ *
+ * Starts a workflow when engagement metrics (likes, comments, shares, views)
+ * on monitored posts hit a configured threshold.
+ *
+ * Node Type: engagementTrigger
+ */
+export class EngagementTriggerExecutor extends BaseExecutor {
+    nodeType = 'engagementTrigger';
+    checker = null;
+    setChecker(checker) {
+        this.checker = checker;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const platform = node.config.platform;
+        const validPlatforms = [
+            'twitter',
+            'instagram',
+            'threads',
+        ];
+        if (!platform ||
+            !validPlatforms.includes(platform)) {
+            errors.push(`Invalid platform. Must be one of: ${validPlatforms.join(', ')}`);
+        }
+        const metricType = node.config.metricType;
+        const validMetrics = [
+            'likes',
+            'comments',
+            'shares',
+            'views',
+        ];
+        if (!metricType ||
+            !validMetrics.includes(metricType)) {
+            errors.push(`Invalid metric type. Must be one of: ${validMetrics.join(', ')}`);
+        }
+        const threshold = node.config.threshold;
+        if (threshold === undefined ||
+            typeof threshold !== 'number' ||
+            threshold <= 0) {
+            errors.push('Threshold must be a positive number');
+        }
+        return { errors, valid: errors.length === 0 };
+    }
+    async execute(input) {
+        const { node, context } = input;
+        if (!this.checker) {
+            throw new Error('Engagement checker not configured');
+        }
+        const platform = this.getRequiredConfig(node.config, 'platform');
+        const postIds = this.getOptionalConfig(node.config, 'postIds', []);
+        const metricType = this.getRequiredConfig(node.config, 'metricType');
+        const threshold = this.getRequiredConfig(node.config, 'threshold');
+        const lastCheckedPostId = this.getOptionalConfig(node.config, 'lastCheckedPostId', null);
+        const result = await this.checker({
+            lastCheckedPostId,
+            metricType,
+            organizationId: context.organizationId,
+            platform,
+            postIds,
+            threshold,
+        });
+        if (!result) {
+            return {
+                data: null,
+                metadata: { matched: false, metricType, platform },
+            };
+        }
+        return {
+            data: result,
+            metadata: {
+                currentValue: result.currentValue,
+                matched: true,
+                metricType: result.metricType,
+                platform,
+                postId: result.postId,
+                threshold: result.threshold,
+            },
+        };
+    }
+    estimateCost(_node) {
+        return 0;
+    }
+}
+export function createEngagementTriggerExecutor() {
+    return new EngagementTriggerExecutor();
+}

package/dist/workflow-engine/src/executors/saas/engagement-trigger-executor.spec.d.ts

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

package/dist/workflow-engine/src/executors/saas/engagement-trigger-executor.spec.d.ts.map

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

package/dist/workflow-engine/src/executors/saas/engagement-trigger-executor.spec.js

@@ -0,0 +1,186 @@
+import { createEngagementTriggerExecutor } from '@workflow-engine/executors/saas/engagement-trigger-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(config) {
+  const node = {
+    config,
+    id: 'trigger-1',
+    inputs: [],
+    label: 'Engagement Trigger',
+    type: 'engagementTrigger',
+  };
+  const context = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs: new Map(), node };
+}
+describe('EngagementTriggerExecutor', () => {
+  let executor;
+  let mockChecker;
+  beforeEach(() => {
+    executor = createEngagementTriggerExecutor();
+    mockChecker = vi.fn().mockResolvedValue({
+      currentValue: 150,
+      metricType: 'likes',
+      platform: 'twitter',
+      postId: 'post-1',
+      postUrl: 'https://x.com/us/status/post-1',
+      threshold: 100,
+      triggeredAt: '2026-02-22T20:00:00Z',
+    });
+    executor.setChecker(mockChecker);
+  });
+  it('creates via factory', () => {
+    expect(executor.nodeType).toBe('engagementTrigger');
+  });
+  it('throws if checker not configured', async () => {
+    const fresh = createEngagementTriggerExecutor();
+    const input = makeInput({
+      metricType: 'likes',
+      platform: 'twitter',
+      threshold: 100,
+    });
+    await expect(fresh.execute(input)).rejects.toThrow(
+      'checker not configured',
+    );
+  });
+  it('returns engagement data when matched', async () => {
+    const input = makeInput({
+      metricType: 'likes',
+      platform: 'twitter',
+      threshold: 100,
+    });
+    const result = await executor.execute(input);
+    expect(result.metadata).toMatchObject({
+      currentValue: 150,
+      matched: true,
+      metricType: 'likes',
+      postId: 'post-1',
+      threshold: 100,
+    });
+    expect(result.data).toMatchObject({
+      currentValue: 150,
+      postId: 'post-1',
+    });
+  });
+  it('returns null when no match', async () => {
+    mockChecker.mockResolvedValue(null);
+    const input = makeInput({
+      metricType: 'likes',
+      platform: 'twitter',
+      threshold: 100,
+    });
+    const result = await executor.execute(input);
+    expect(result.metadata).toMatchObject({
+      matched: false,
+      metricType: 'likes',
+    });
+    expect(result.data).toBeNull();
+  });
+  it('passes postIds and threshold to checker', async () => {
+    const input = makeInput({
+      metricType: 'comments',
+      platform: 'instagram',
+      postIds: ['p1', 'p2'],
+      threshold: 50,
+    });
+    await executor.execute(input);
+    expect(mockChecker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metricType: 'comments',
+        platform: 'instagram',
+        postIds: ['p1', 'p2'],
+        threshold: 50,
+      }),
+    );
+  });
+  it('validates platform', () => {
+    const node = {
+      config: { metricType: 'likes', platform: 'tiktok', threshold: 100 },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    expect(executor.validate(node).valid).toBe(false);
+  });
+  it('validates metric type', () => {
+    const node = {
+      config: { metricType: 'followers', platform: 'twitter', threshold: 100 },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toContain('Invalid metric type');
+  });
+  it('validates threshold is required', () => {
+    const node = {
+      config: { metricType: 'likes', platform: 'twitter' },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Threshold must be a positive number');
+  });
+  it('validates threshold must be positive', () => {
+    const node = {
+      config: { metricType: 'likes', platform: 'twitter', threshold: 0 },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Threshold must be a positive number');
+  });
+  it('validates threshold must be a number', () => {
+    const node = {
+      config: {
+        metricType: 'likes',
+        platform: 'twitter',
+        threshold: 'high',
+      },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Threshold must be a positive number');
+  });
+  it('accepts valid config', () => {
+    const node = {
+      config: {
+        metricType: 'shares',
+        platform: 'threads',
+        threshold: 25,
+      },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    expect(executor.validate(node).valid).toBe(true);
+  });
+  it('estimates cost as zero', () => {
+    const node = {
+      config: { metricType: 'likes', platform: 'twitter', threshold: 100 },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'engagementTrigger',
+    };
+    expect(executor.estimateCost(node)).toBe(0);
+  });
+});

package/dist/workflow-engine/src/executors/saas/film-grain-executor.d.ts

@@ -0,0 +1,53 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type FilmStock = '35mm_fine' | '35mm_heavy' | '16mm' | '8mm' | 'digital_noise';
+export type GrainSize = 'fine' | 'medium' | 'coarse';
+export interface FilmGrainParams {
+    stock: FilmStock;
+    intensity: number;
+    size: GrainSize;
+    colorGrain: boolean;
+}
+/** Extended config used by cinematic camera presets */
+export interface FilmGrainConfig extends FilmGrainParams {
+    enabled?: boolean;
+    animateGrain?: boolean;
+}
+export interface FilmGrainResult {
+    outputUrl: string;
+    jobId: string;
+}
+/**
+ * Builds an FFmpeg filter string for film grain simulation.
+ */
+export declare function buildFilmGrainFilter(params: FilmGrainParams): string;
+export type FilmGrainProcessor = (params: {
+    organizationId: string;
+    videoUrl: string;
+    filterChain: string;
+    stock: FilmStock;
+    intensity: number;
+}) => Promise<FilmGrainResult>;
+/**
+ * Film Grain Executor
+ *
+ * Applies cinematic film grain to video via FFmpeg noise filters.
+ * Supports stock emulation (35mm, 16mm, 8mm) and digital noise,
+ * with configurable intensity, size, and chromatic grain toggle.
+ *
+ * Node Type: filmGrain
+ * Category: effects
+ */
+export declare class FilmGrainExecutor extends BaseExecutor {
+    readonly nodeType = "filmGrain";
+    private processor;
+    setProcessor(processor: FilmGrainProcessor): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createFilmGrainExecutor(processor?: FilmGrainProcessor): FilmGrainExecutor;
+//# sourceMappingURL=film-grain-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/film-grain-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"film-grain-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/film-grain-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,MAAM,SAAS,GACjB,WAAW,GACX,YAAY,GACZ,MAAM,GACN,KAAK,GACL,eAAe,CAAC;AAEpB,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,uDAAuD;AACvD,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAgCD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAiCpE;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;AAE/B;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,QAAQ,CAAC,QAAQ,eAAe;IAChC,OAAO,CAAC,SAAS,CAAmC;IAEpD,YAAY,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI;IAIjD,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAiCpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAIrC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAmD7D;AAED,wBAAgB,uBAAuB,CACrC,SAAS,CAAC,EAAE,kBAAkB,GAC7B,iBAAiB,CAMnB"}

package/dist/workflow-engine/src/executors/saas/film-grain-executor.js

@@ -0,0 +1,135 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Stock preset mappings to FFmpeg noise parameters.
+ */
+const STOCK_PRESETS = {
+    '8mm': { heavyTemporal: true, strength: 25, temporal: true },
+    '16mm': { heavyTemporal: false, strength: 20, temporal: true },
+    '35mm_fine': { heavyTemporal: false, strength: 10, temporal: true },
+    '35mm_heavy': { heavyTemporal: false, strength: 30, temporal: true },
+    digital_noise: { heavyTemporal: false, strength: 15, temporal: false },
+};
+const SIZE_MULTIPLIERS = {
+    coarse: 1.4,
+    fine: 0.7,
+    medium: 1.0,
+};
+const VALID_STOCKS = [
+    '35mm_fine',
+    '35mm_heavy',
+    '16mm',
+    '8mm',
+    'digital_noise',
+];
+const VALID_SIZES = ['fine', 'medium', 'coarse'];
+/**
+ * Builds an FFmpeg filter string for film grain simulation.
+ */
+export function buildFilmGrainFilter(params) {
+    const preset = STOCK_PRESETS[params.stock];
+    const sizeMultiplier = SIZE_MULTIPLIERS[params.size];
+    const baseStrength = preset.strength * (params.intensity / 100) * sizeMultiplier;
+    const strength = Math.max(0, Math.min(100, Math.round(baseStrength)));
+    if (strength === 0)
+        return '';
+    const flags = [];
+    if (preset.temporal)
+        flags.push('t');
+    flags.push('u');
+    const flagStr = flags.join('+');
+    const filters = [];
+    if (!params.colorGrain) {
+        filters.push(`noise=alls=${strength}:allf=${flagStr}`);
+    }
+    else {
+        const rStrength = strength;
+        const gStrength = Math.round(strength * 0.85);
+        const bStrength = Math.round(strength * 0.9);
+        filters.push(`noise=c0s=${rStrength}:c0f=${flagStr}:c1s=${gStrength}:c1f=${flagStr}:c2s=${bStrength}:c2f=${flagStr}`);
+    }
+    if (preset.heavyTemporal) {
+        filters.push('tmix=frames=2:weights=1 0.5');
+    }
+    return filters.join(',');
+}
+/**
+ * Film Grain Executor
+ *
+ * Applies cinematic film grain to video via FFmpeg noise filters.
+ * Supports stock emulation (35mm, 16mm, 8mm) and digital noise,
+ * with configurable intensity, size, and chromatic grain toggle.
+ *
+ * Node Type: filmGrain
+ * Category: effects
+ */
+export class FilmGrainExecutor extends BaseExecutor {
+    nodeType = 'filmGrain';
+    processor = null;
+    setProcessor(processor) {
+        this.processor = processor;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const stock = node.config.stock;
+        if (stock && !VALID_STOCKS.includes(stock)) {
+            errors.push(`Invalid stock. Must be one of: ${VALID_STOCKS.join(', ')}`);
+        }
+        const intensity = node.config.intensity;
+        if (intensity !== undefined &&
+            (typeof intensity !== 'number' || intensity < 0 || intensity > 100)) {
+            errors.push('intensity must be a number between 0 and 100');
+        }
+        const size = node.config.size;
+        if (size && !VALID_SIZES.includes(size)) {
+            errors.push(`Invalid size. Must be one of: ${VALID_SIZES.join(', ')}`);
+        }
+        const colorGrain = node.config.colorGrain;
+        if (colorGrain !== undefined && typeof colorGrain !== 'boolean') {
+            errors.push('colorGrain must be a boolean');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 0;
+    }
+    async execute(input) {
+        const { node, inputs, context } = input;
+        if (!this.processor) {
+            throw new Error('Film grain processor not configured');
+        }
+        const videoUrl = this.getRequiredInput(inputs, 'videoUrl');
+        const stock = this.getOptionalConfig(node.config, 'stock', '35mm_fine');
+        const intensity = this.getOptionalConfig(node.config, 'intensity', 50);
+        const size = this.getOptionalConfig(node.config, 'size', 'medium');
+        const colorGrain = this.getOptionalConfig(node.config, 'colorGrain', false);
+        const params = { colorGrain, intensity, size, stock };
+        const filterChain = buildFilmGrainFilter(params);
+        const result = await this.processor({
+            filterChain,
+            intensity,
+            organizationId: context.organizationId,
+            stock,
+            videoUrl,
+        });
+        return {
+            data: result.outputUrl,
+            metadata: {
+                filterChain,
+                jobId: result.jobId,
+                params,
+                stock,
+            },
+        };
+    }
+}
+export function createFilmGrainExecutor(processor) {
+    const executor = new FilmGrainExecutor();
+    if (processor) {
+        executor.setProcessor(processor);
+    }
+    return executor;
+}

package/dist/workflow-engine/src/executors/saas/film-grain-executor.spec.d.ts

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

package/dist/workflow-engine/src/executors/saas/film-grain-executor.spec.d.ts.map

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

package/dist/workflow-engine/src/executors/saas/film-grain-executor.spec.js

@@ -0,0 +1,176 @@
+import {
+  buildFilmGrainFilter,
+  createFilmGrainExecutor,
+  FilmGrainExecutor,
+} from '@workflow-engine/executors/saas/film-grain-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(config, inputData) {
+  const node = {
+    config,
+    id: 'grain-1',
+    inputs: [],
+    label: 'Film Grain',
+    type: 'filmGrain',
+  };
+  const inputs = new Map();
+  if (inputData) {
+    for (const [k, v] of Object.entries(inputData)) {
+      inputs.set(k, v);
+    }
+  }
+  const context = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+describe('FilmGrainExecutor', () => {
+  let executor;
+  beforeEach(() => {
+    executor = new FilmGrainExecutor();
+  });
+  describe('validate', () => {
+    it('passes with valid config', () => {
+      const input = makeInput({
+        colorGrain: false,
+        intensity: 50,
+        size: 'medium',
+        stock: '35mm_fine',
+      });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+    it('rejects invalid stock', () => {
+      const input = makeInput({ stock: 'invalid' });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('Invalid stock'))).toBe(true);
+    });
+    it('rejects intensity out of range', () => {
+      const input = makeInput({ intensity: 150 });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+    });
+    it('rejects invalid size', () => {
+      const input = makeInput({ size: 'huge' });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+    });
+    it('rejects non-boolean colorGrain', () => {
+      const input = makeInput({ colorGrain: 'yes' });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('colorGrain'))).toBe(true);
+    });
+  });
+  describe('execute', () => {
+    it('calls processor with filter chain', async () => {
+      const processor = vi.fn().mockResolvedValue({
+        jobId: 'job-123',
+        outputUrl: 'https://cdn.example.com/output.mp4',
+      });
+      executor.setProcessor(processor);
+      const input = makeInput(
+        {
+          colorGrain: true,
+          intensity: 80,
+          size: 'coarse',
+          stock: '35mm_heavy',
+        },
+        { videoUrl: 'https://cdn.example.com/input.mp4' },
+      );
+      const result = await executor.execute(input);
+      expect(processor).toHaveBeenCalledOnce();
+      const call = processor.mock.calls[0][0];
+      expect(call.videoUrl).toBe('https://cdn.example.com/input.mp4');
+      expect(call.stock).toBe('35mm_heavy');
+      expect(call.filterChain).toBeTruthy();
+      expect(result.data).toBe('https://cdn.example.com/output.mp4');
+    });
+    it('throws if processor not set', async () => {
+      const input = makeInput({}, { videoUrl: 'https://example.com/v.mp4' });
+      await expect(executor.execute(input)).rejects.toThrow(
+        'Film grain processor not configured',
+      );
+    });
+    it('throws if videoUrl missing', async () => {
+      executor.setProcessor(vi.fn());
+      const input = makeInput({}, {});
+      await expect(executor.execute(input)).rejects.toThrow(
+        'Missing required input: videoUrl',
+      );
+    });
+  });
+  describe('estimateCost', () => {
+    it('returns 0', () => {
+      const input = makeInput({});
+      expect(executor.estimateCost(input.node)).toBe(0);
+    });
+  });
+});
+describe('buildFilmGrainFilter', () => {
+  it('generates noise filter for 35mm_fine', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 100,
+      size: 'medium',
+      stock: '35mm_fine',
+    });
+    expect(filter).toContain('noise=alls=');
+    expect(filter).toContain('allf=t+u');
+  });
+  it('generates per-channel noise for color grain', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: true,
+      intensity: 100,
+      size: 'medium',
+      stock: '35mm_fine',
+    });
+    expect(filter).toContain('c0s=');
+    expect(filter).toContain('c1s=');
+    expect(filter).toContain('c2s=');
+  });
+  it('returns empty string for zero intensity', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 0,
+      size: 'medium',
+      stock: '35mm_fine',
+    });
+    expect(filter).toBe('');
+  });
+  it('adds tmix for 8mm stock', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 100,
+      size: 'medium',
+      stock: '8mm',
+    });
+    expect(filter).toContain('tmix');
+  });
+  it('does not add temporal flag for digital_noise', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 100,
+      size: 'medium',
+      stock: 'digital_noise',
+    });
+    expect(filter).not.toContain('t+u');
+    expect(filter).toContain('allf=u');
+  });
+});
+describe('createFilmGrainExecutor', () => {
+  it('creates executor without processor', () => {
+    const executor = createFilmGrainExecutor();
+    expect(executor.nodeType).toBe('filmGrain');
+  });
+  it('creates executor with processor', () => {
+    const processor = vi.fn();
+    const executor = createFilmGrainExecutor(processor);
+    expect(executor.nodeType).toBe('filmGrain');
+  });
+});

package/dist/workflow-engine/src/executors/saas/image-gen-executor.d.ts

@@ -0,0 +1,28 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface ImageGenOutput {
+    imageUrl: string;
+    imageBuffer?: Buffer;
+    filename?: string;
+    model: string;
+    provider: string;
+}
+/**
+ * Resolver that generates an image using the specified model/provider.
+ * The actual implementation is injected at runtime from the NestJS service layer.
+ */
+export type ImageGenResolver = (model: string, params: Record<string, unknown>, context: ExecutionContext, node: ExecutableNode) => Promise<ImageGenOutput>;
+export declare class ImageGenExecutor extends BaseExecutor {
+    readonly nodeType = "imageGen";
+    private resolver;
+    setResolver(resolver: ImageGenResolver): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createImageGenExecutor(): ImageGenExecutor;
+//# sourceMappingURL=image-gen-executor.d.ts.map