@genfeedai/workflow-saas 0.2.0

package/src/nodes/image-text-overlay.ts

@@ -0,0 +1,118 @@
+/**
+ * Image Text Overlay Node
+ *
+ * SAAS category node that renders text onto a static image (PNG/JPEG)
+ * using Sharp. Specifically designed for burning hook text onto slide 1
+ * of a TikTok slideshow for maximum engagement.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Vertical position of the text overlay on the image
+ */
+export type TextPosition = 'top' | 'center' | 'bottom';
+
+/**
+ * Horizontal alignment of the text overlay
+ */
+export type TextAlignment = 'left' | 'center' | 'right';
+
+/**
+ * Style configuration for text overlay rendering
+ */
+export interface TextOverlayStyle {
+  fontSize: number;
+  fontFamily: string;
+  fontWeight: 'normal' | 'bold' | 'black';
+  color: string;
+  strokeColor: string;
+  strokeWidth: number;
+  position: TextPosition;
+  alignment: TextAlignment;
+  paddingX: number;
+  paddingY: number;
+  maxWidthPercent: number;
+  lineHeight: number;
+}
+
+/**
+ * Default style optimized for TikTok readability:
+ * large white text with black stroke for contrast against any background
+ */
+export const DEFAULT_TEXT_OVERLAY_STYLE: TextOverlayStyle = {
+  alignment: 'center',
+  color: '#FFFFFF',
+  fontFamily: 'Montserrat',
+  fontSize: 72,
+  fontWeight: 'black',
+  lineHeight: 1.2,
+  maxWidthPercent: 90,
+  paddingX: 40,
+  paddingY: 60,
+  position: 'center',
+  strokeColor: '#000000',
+  strokeWidth: 3,
+};
+
+/**
+ * Image Text Overlay Node Data
+ *
+ * Inputs:
+ * - image (image): Image to overlay text on (required)
+ * - text (text): Text to render, typically from HookGenerator (required)
+ *
+ * Outputs:
+ * - image (image): Image with text burned in
+ */
+export interface ImageTextOverlayNodeData extends BaseNodeData {
+  type: 'imageTextOverlay';
+
+  // Input from connections
+  inputImageUrl: string | null;
+  inputText: string | null;
+
+  // Configuration
+  style: TextOverlayStyle;
+  slideIndex: number;
+
+  // Output
+  outputImageUrl: string | null;
+
+  // Job state
+  jobId: string | null;
+}
+
+/**
+ * Default data for a new Image Text Overlay node
+ */
+export const DEFAULT_IMAGE_TEXT_OVERLAY_DATA: Partial<ImageTextOverlayNodeData> =
+  {
+    inputImageUrl: null,
+    inputText: null,
+    jobId: null,
+    label: 'Image Text Overlay',
+    outputImageUrl: null,
+    slideIndex: 0,
+    status: 'idle',
+    style: { ...DEFAULT_TEXT_OVERLAY_STYLE },
+    type: 'imageTextOverlay',
+  };
+
+/**
+ * Image Text Overlay node definition for registry
+ */
+export const imageTextOverlayNodeDefinition = {
+  category: 'saas' as const,
+  defaultData: DEFAULT_IMAGE_TEXT_OVERLAY_DATA,
+  description:
+    'Burn text overlay onto static images for TikTok slideshow hooks',
+  icon: 'Type',
+  inputs: [
+    { id: 'image', label: 'Image', required: true, type: 'image' },
+    { id: 'text', label: 'Text', required: true, type: 'text' },
+  ],
+  label: 'Image Text Overlay',
+  outputs: [{ id: 'image', label: 'Image with Text', type: 'image' }],
+  type: 'imageTextOverlay',
+};

package/src/nodes/index.ts

@@ -0,0 +1,39 @@
+export * from './beat-analysis';
+export * from './beat-sync-editor';
+export * from './brand';
+export * from './brand-asset';
+export * from './brand-context';
+export * from './condition';
+export * from './delay';
+export * from './engagement-trigger';
+export * from './follow-user';
+// TikTok slideshow automation nodes
+export * from './hook-generator';
+// Hook performance tracking
+export * from './hook-performance-tracker';
+export * from './image-text-overlay';
+export * from './keyword-trigger';
+export * from './like-post';
+export * from './music-source';
+export * from './pattern-context';
+export * from './persona-content-plan';
+// Persona content nodes
+export * from './persona-photo-session';
+export * from './persona-video-content';
+export * from './post-reply';
+export * from './publish';
+export * from './rss-input';
+export * from './send-dm';
+export * from './slideshow-image-batch';
+export * from './social-publish';
+export * from './sound-overlay';
+export * from './trend-hashtag-inspiration';
+// Trend automation nodes - shared types first
+export * from './trend-shared';
+export * from './trend-sound-inspiration';
+export * from './trend-trigger';
+export * from './trend-video-inspiration';
+export * from './tweet-input';
+export * from './tweet-remix';
+// Beat-synced video editor nodes
+export * from './video-input';

package/src/nodes/keyword-trigger.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_KEYWORD_TRIGGER_DATA,
+  keywordTriggerNodeDefinition,
+} from './keyword-trigger';
+
+describe('keyword-trigger node', () => {
+  describe('DEFAULT_KEYWORD_TRIGGER_DATA', () => {
+    it('should have label set to Keyword Trigger', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.label).toBe('Keyword Trigger');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to keywordTrigger', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.type).toBe('keywordTrigger');
+    });
+
+    it('should default platform to twitter', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.platform).toBe('twitter');
+    });
+
+    it('should default matchMode to contains', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.matchMode).toBe('contains');
+    });
+
+    it('should default caseSensitive to false', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.caseSensitive).toBe(false);
+    });
+
+    it('should default keywords and excludeKeywords to empty arrays', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.keywords).toEqual([]);
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.excludeKeywords).toEqual([]);
+    });
+
+    it('should default tracking fields to null', () => {
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.lastPostId).toBeNull();
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.lastTriggeredAt).toBeNull();
+      expect(DEFAULT_KEYWORD_TRIGGER_DATA.lastMatchedKeyword).toBeNull();
+    });
+  });
+
+  describe('keywordTriggerNodeDefinition', () => {
+    it('should have type keywordTrigger', () => {
+      expect(keywordTriggerNodeDefinition.type).toBe('keywordTrigger');
+    });
+
+    it('should be in trigger category', () => {
+      expect(keywordTriggerNodeDefinition.category).toBe('trigger');
+    });
+
+    it('should have label Keyword Trigger', () => {
+      expect(keywordTriggerNodeDefinition.label).toBe('Keyword Trigger');
+    });
+
+    it('should have no inputs (trigger node)', () => {
+      expect(keywordTriggerNodeDefinition.inputs).toEqual([]);
+    });
+
+    it('should output post details and matched keyword', () => {
+      const outputIds = keywordTriggerNodeDefinition.outputs.map((o) => o.id);
+      expect(outputIds).toContain('postId');
+      expect(outputIds).toContain('text');
+      expect(outputIds).toContain('matchedKeyword');
+      expect(outputIds).toContain('platform');
+    });
+
+    it('should reference default data', () => {
+      expect(keywordTriggerNodeDefinition.defaultData).toBe(
+        DEFAULT_KEYWORD_TRIGGER_DATA,
+      );
+    });
+  });
+});

package/src/nodes/keyword-trigger.ts

@@ -0,0 +1,67 @@
+/**
+ * Keyword Trigger Node Types
+ *
+ * This node starts a workflow when a keyword or phrase is detected
+ * in incoming social posts. Supports exact match, contains, and regex modes.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+export type KeywordTriggerPlatform = 'twitter' | 'instagram' | 'threads';
+
+export type KeywordMatchMode = 'exact' | 'contains' | 'regex';
+
+export interface KeywordTriggerNodeData extends BaseNodeData {
+  type: 'keywordTrigger';
+
+  /** Platform to monitor */
+  platform: KeywordTriggerPlatform;
+  /** Keywords or phrases to match */
+  keywords: string[];
+  /** Keywords to exclude from matching */
+  excludeKeywords: string[];
+  /** How to match keywords */
+  matchMode: KeywordMatchMode;
+  /** Whether matching should be case sensitive */
+  caseSensitive: boolean;
+
+  /** Last matched post ID (for deduplication) */
+  lastPostId: string | null;
+  /** Last triggered timestamp (for display) */
+  lastTriggeredAt: string | null;
+  /** Last matched keyword (for display) */
+  lastMatchedKeyword: string | null;
+}
+
+export const DEFAULT_KEYWORD_TRIGGER_DATA: Partial<KeywordTriggerNodeData> = {
+  caseSensitive: false,
+  excludeKeywords: [],
+  keywords: [],
+  label: 'Keyword Trigger',
+  lastMatchedKeyword: null,
+  lastPostId: null,
+  lastTriggeredAt: null,
+  matchMode: 'contains',
+  platform: 'twitter',
+  status: 'idle',
+  type: 'keywordTrigger',
+};
+
+export const keywordTriggerNodeDefinition = {
+  category: 'trigger' as const,
+  defaultData: DEFAULT_KEYWORD_TRIGGER_DATA,
+  description: 'Start workflow when keyword is detected in social posts',
+  icon: 'Search',
+  inputs: [],
+  label: 'Keyword Trigger',
+  outputs: [
+    { id: 'postId', label: 'Post ID', type: 'text' },
+    { id: 'postUrl', label: 'Post URL', type: 'text' },
+    { id: 'text', label: 'Post Text', type: 'text' },
+    { id: 'matchedKeyword', label: 'Matched Keyword', type: 'text' },
+    { id: 'authorId', label: 'Author ID', type: 'text' },
+    { id: 'authorUsername', label: 'Author Username', type: 'text' },
+    { id: 'platform', label: 'Platform', type: 'text' },
+  ],
+  type: 'keywordTrigger',
+};

package/src/nodes/like-post.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_LIKE_POST_DATA } from './like-post';
+
+describe('like-post node', () => {
+  describe('DEFAULT_LIKE_POST_DATA', () => {
+    it('should have label set to Like Post', () => {
+      expect(DEFAULT_LIKE_POST_DATA.label).toBe('Like Post');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_LIKE_POST_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to likePost', () => {
+      expect(DEFAULT_LIKE_POST_DATA.type).toBe('likePost');
+    });
+
+    it('should default platform to twitter', () => {
+      expect(DEFAULT_LIKE_POST_DATA.platform).toBe('twitter');
+    });
+
+    it('should default postId to empty string', () => {
+      expect(DEFAULT_LIKE_POST_DATA.postId).toBe('');
+    });
+
+    it('should default accountId to empty string', () => {
+      expect(DEFAULT_LIKE_POST_DATA.accountId).toBe('');
+    });
+  });
+});

package/src/nodes/like-post.ts

@@ -0,0 +1,43 @@
+/**
+ * Like Post Node
+ *
+ * ACTION category node that likes/favorites a social media post.
+ * Requires brand input for credentials resolution.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+export type LikePostPlatform = 'twitter' | 'instagram' | 'threads' | 'facebook';
+
+/**
+ * Like Post Node Data
+ *
+ * Inputs:
+ * - brand (brand): Brand context (required)
+ * - postId (text): The post ID to like (required)
+ *
+ * Outputs:
+ * - success (text): Whether the like was successful
+ */
+export interface LikePostNodeData extends BaseNodeData {
+  type: 'likePost';
+
+  /** Platform to like on */
+  platform: LikePostPlatform;
+  /** Post ID to like */
+  postId: string;
+  /** Optional specific account ID if brand has multiple */
+  accountId: string;
+}
+
+/**
+ * Default data for a new Like Post node
+ */
+export const DEFAULT_LIKE_POST_DATA: Partial<LikePostNodeData> = {
+  accountId: '',
+  label: 'Like Post',
+  platform: 'twitter',
+  postId: '',
+  status: 'idle',
+  type: 'likePost',
+};

package/src/nodes/music-source.spec.ts

@@ -0,0 +1,82 @@
+import { MusicSourceType } from '@genfeedai/enums';
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_MUSIC_SOURCE_DATA,
+  musicSourceNodeDefinition,
+} from './music-source';
+
+describe('music-source node', () => {
+  describe('DEFAULT_MUSIC_SOURCE_DATA', () => {
+    it('should have label set to Music Source', () => {
+      expect(DEFAULT_MUSIC_SOURCE_DATA.label).toBe('Music Source');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_MUSIC_SOURCE_DATA.status).toBe('idle');
+    });
+
+    it('should default sourceType to LIBRARY', () => {
+      expect(DEFAULT_MUSIC_SOURCE_DATA.sourceType).toBe(
+        MusicSourceType.LIBRARY,
+      );
+    });
+
+    it('should default trendMinUsage to 10000', () => {
+      expect(DEFAULT_MUSIC_SOURCE_DATA.trendMinUsage).toBe(10000);
+    });
+
+    it('should default generateDuration to 30', () => {
+      expect(DEFAULT_MUSIC_SOURCE_DATA.generateDuration).toBe(30);
+    });
+
+    it('should default all nullable fields to null', () => {
+      expect(DEFAULT_MUSIC_SOURCE_DATA.trendPlatform).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.libraryCategory).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.libraryMood).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.uploadUrl).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.generatePrompt).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.musicUrl).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.duration).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.tempo).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.title).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.artist).toBeNull();
+      expect(DEFAULT_MUSIC_SOURCE_DATA.coverUrl).toBeNull();
+    });
+  });
+
+  describe('musicSourceNodeDefinition', () => {
+    it('should have type musicSource', () => {
+      expect(musicSourceNodeDefinition.type).toBe('musicSource');
+    });
+
+    it('should be in input category', () => {
+      expect(musicSourceNodeDefinition.category).toBe('input');
+    });
+
+    it('should have label Music Source', () => {
+      expect(musicSourceNodeDefinition.label).toBe('Music Source');
+    });
+
+    it('should have optional inputs for uploadUrl and generatePrompt', () => {
+      const upload = musicSourceNodeDefinition.inputs.find(
+        (i) => i.id === 'uploadUrl',
+      );
+      const prompt = musicSourceNodeDefinition.inputs.find(
+        (i) => i.id === 'generatePrompt',
+      );
+      expect(upload?.required).toBe(false);
+      expect(prompt?.required).toBe(false);
+    });
+
+    it('should output musicUrl, duration, tempo, and title', () => {
+      const outputIds = musicSourceNodeDefinition.outputs.map((o) => o.id);
+      expect(outputIds).toEqual(['musicUrl', 'duration', 'tempo', 'title']);
+    });
+
+    it('should reference default data', () => {
+      expect(musicSourceNodeDefinition.defaultData).toBe(
+        DEFAULT_MUSIC_SOURCE_DATA,
+      );
+    });
+  });
+});

package/src/nodes/music-source.ts

@@ -0,0 +1,77 @@
+/**
+ * Music Source Node Types
+ *
+ * This node resolves music from various sources for beat-synced editing.
+ * Supports trending sounds, curated library, user uploads, and AI generation.
+ */
+
+import { MusicSourceType } from '@genfeedai/enums';
+import type { BaseTrendNodeData } from './trend-shared';
+
+export interface MusicSourceNodeData extends BaseTrendNodeData {
+  // Configuration
+  sourceType: MusicSourceType;
+
+  // Trend sound options
+  trendPlatform: 'tiktok' | 'instagram' | null;
+  trendMinUsage: number;
+
+  // Library options
+  libraryCategory: string | null;
+  libraryMood: string | null;
+
+  // Upload options
+  uploadUrl: string | null;
+
+  // Generate options
+  generatePrompt: string | null;
+  generateDuration: number;
+
+  // Outputs
+  musicUrl: string | null;
+  duration: number | null;
+  tempo: number | null;
+  title: string | null;
+
+  // Additional info
+  artist: string | null;
+  coverUrl: string | null;
+}
+
+export const DEFAULT_MUSIC_SOURCE_DATA: Partial<MusicSourceNodeData> = {
+  artist: null,
+  coverUrl: null,
+  duration: null,
+  generateDuration: 30,
+  generatePrompt: null,
+  label: 'Music Source',
+  libraryCategory: null,
+  libraryMood: null,
+  musicUrl: null,
+  sourceType: MusicSourceType.LIBRARY,
+  status: 'idle',
+  tempo: null,
+  title: null,
+  trendMinUsage: 10000,
+  trendPlatform: null,
+  uploadUrl: null,
+};
+
+export const musicSourceNodeDefinition = {
+  category: 'input' as const,
+  defaultData: DEFAULT_MUSIC_SOURCE_DATA,
+  description: 'Resolve music from trends, library, upload, or AI generation',
+  icon: 'Music',
+  inputs: [
+    { id: 'uploadUrl', label: 'Upload URL', required: false, type: 'text' },
+    { id: 'generatePrompt', label: 'AI Prompt', required: false, type: 'text' },
+  ],
+  label: 'Music Source',
+  outputs: [
+    { id: 'musicUrl', label: 'Music URL', type: 'text' },
+    { id: 'duration', label: 'Duration (s)', type: 'number' },
+    { id: 'tempo', label: 'Tempo (BPM)', type: 'number' },
+    { id: 'title', label: 'Title', type: 'text' },
+  ],
+  type: 'musicSource',
+};

package/src/nodes/nodes.spec.ts

@@ -0,0 +1,59 @@
+import {
+  DEFAULT_BEAT_ANALYSIS_DATA,
+  DEFAULT_BEAT_SYNC_EDITOR_DATA,
+  DEFAULT_BRAND_ASSET_DATA,
+  DEFAULT_BRAND_CONTEXT_DATA,
+  DEFAULT_BRAND_DATA,
+  DEFAULT_ENGAGEMENT_TRIGGER_DATA,
+  DEFAULT_HOOK_GENERATOR_DATA,
+  DEFAULT_IMAGE_TEXT_OVERLAY_DATA,
+  DEFAULT_KEYWORD_TRIGGER_DATA,
+  DEFAULT_MUSIC_SOURCE_DATA,
+  DEFAULT_PERSONA_CONTENT_PLAN_DATA,
+  DEFAULT_PERSONA_PHOTO_SESSION_DATA,
+  DEFAULT_PERSONA_VIDEO_CONTENT_DATA,
+  DEFAULT_PUBLISH_DATA,
+  DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA,
+  DEFAULT_SOUND_OVERLAY_DATA,
+  DEFAULT_TREND_HASHTAG_INSPIRATION_DATA,
+  DEFAULT_TREND_SOUND_INSPIRATION_DATA,
+  DEFAULT_TREND_TRIGGER_DATA,
+  DEFAULT_TREND_VIDEO_INSPIRATION_DATA,
+  DEFAULT_VIDEO_INPUT_DATA,
+} from '@workflow-saas/nodes';
+import { describe, expect, it } from 'vitest';
+
+const allDefaults: Record<string, unknown> = {
+  beatAnalysis: DEFAULT_BEAT_ANALYSIS_DATA,
+  beatSyncEditor: DEFAULT_BEAT_SYNC_EDITOR_DATA,
+  brand: DEFAULT_BRAND_DATA,
+  brandAsset: DEFAULT_BRAND_ASSET_DATA,
+  brandContext: DEFAULT_BRAND_CONTEXT_DATA,
+  engagementTrigger: DEFAULT_ENGAGEMENT_TRIGGER_DATA,
+  hookGenerator: DEFAULT_HOOK_GENERATOR_DATA,
+  imageTextOverlay: DEFAULT_IMAGE_TEXT_OVERLAY_DATA,
+  keywordTrigger: DEFAULT_KEYWORD_TRIGGER_DATA,
+  musicSource: DEFAULT_MUSIC_SOURCE_DATA,
+  personaContentPlan: DEFAULT_PERSONA_CONTENT_PLAN_DATA,
+  personaPhotoSession: DEFAULT_PERSONA_PHOTO_SESSION_DATA,
+  personaVideoContent: DEFAULT_PERSONA_VIDEO_CONTENT_DATA,
+  publish: DEFAULT_PUBLISH_DATA,
+  slideshowImageBatch: DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA,
+  soundOverlay: DEFAULT_SOUND_OVERLAY_DATA,
+  trendHashtagInspiration: DEFAULT_TREND_HASHTAG_INSPIRATION_DATA,
+  trendSoundInspiration: DEFAULT_TREND_SOUND_INSPIRATION_DATA,
+  trendTrigger: DEFAULT_TREND_TRIGGER_DATA,
+  trendVideoInspiration: DEFAULT_TREND_VIDEO_INSPIRATION_DATA,
+  videoInput: DEFAULT_VIDEO_INPUT_DATA,
+};
+
+describe('node default data', () => {
+  for (const [name, data] of Object.entries(allDefaults)) {
+    describe(name, () => {
+      it('is defined and has label', () => {
+        expect(data).toBeDefined();
+        expect((data as any).label).toBeTruthy();
+      });
+    });
+  }
+});

package/src/nodes/pattern-context.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_PATTERN_CONTEXT_DATA } from './pattern-context';
+
+describe('pattern-context node', () => {
+  describe('DEFAULT_PATTERN_CONTEXT_DATA', () => {
+    it('should have label set to Pattern Context', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.label).toBe('Pattern Context');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.status).toBe('idle');
+    });
+
+    it('should default brandId to null', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.brandId).toBeNull();
+    });
+
+    it('should default limit to 10', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.limit).toBe(10);
+    });
+
+    it('should default patternTypes to empty array', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.patternTypes).toEqual([]);
+    });
+
+    it('should default patterns to empty array', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.patterns).toEqual([]);
+    });
+
+    it('should default jobId to null', () => {
+      expect(DEFAULT_PATTERN_CONTEXT_DATA.jobId).toBeNull();
+    });
+  });
+});

package/src/nodes/pattern-context.ts

@@ -0,0 +1,37 @@
+import type { ICreativePattern } from '@genfeedai/interfaces';
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Pattern Context Node Data
+ *
+ * Retrieves proven creative patterns for a brand from performance data
+ * and makes them available to downstream workflow nodes.
+ *
+ * Outputs:
+ * - patterns (object): Array of creative patterns matched to the brand
+ */
+export interface PatternContextNodeData extends BaseNodeData {
+  // Configuration
+  brandId: string | null;
+  patternTypes: string[];
+  limit: number;
+
+  // Resolved at execution time
+  patterns: ICreativePattern[];
+
+  // Job state
+  jobId: string | null;
+}
+
+/**
+ * Default data for a new Pattern Context node
+ */
+export const DEFAULT_PATTERN_CONTEXT_DATA: Partial<PatternContextNodeData> = {
+  brandId: null,
+  jobId: null,
+  label: 'Pattern Context',
+  limit: 10,
+  patterns: [],
+  patternTypes: [],
+  status: 'idle',
+};