@genfeedai/workflow-saas 0.2.0

package/dist/workflow-saas/src/nodes/tweet-remix.spec.js

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { defaultTweetRemixData, tweetRemixNodeDefinition } from './tweet-remix';
+
+describe('tweet-remix node', () => {
+  describe('defaultTweetRemixData', () => {
+    it('should have label set to Tweet Remix', () => {
+      expect(defaultTweetRemixData.label).toBe('Tweet Remix');
+    });
+    it('should default to idle status', () => {
+      expect(defaultTweetRemixData.status).toBe('idle');
+    });
+    it('should default tone to professional', () => {
+      expect(defaultTweetRemixData.tone).toBe('professional');
+    });
+    it('should default maxLength to 280 (Twitter character limit)', () => {
+      expect(defaultTweetRemixData.maxLength).toBe(280);
+    });
+    it('should default variations to empty array', () => {
+      expect(defaultTweetRemixData.variations).toEqual([]);
+    });
+    it('should default nullable fields to null', () => {
+      expect(defaultTweetRemixData.inputTweet).toBeNull();
+      expect(defaultTweetRemixData.selectedIndex).toBeNull();
+      expect(defaultTweetRemixData.outputTweet).toBeNull();
+      expect(defaultTweetRemixData.jobId).toBeNull();
+    });
+  });
+  describe('tweetRemixNodeDefinition', () => {
+    it('should have type tweetRemix', () => {
+      expect(tweetRemixNodeDefinition.type).toBe('tweetRemix');
+    });
+    it('should be in ai category', () => {
+      expect(tweetRemixNodeDefinition.category).toBe('ai');
+    });
+    it('should have label Tweet Remix', () => {
+      expect(tweetRemixNodeDefinition.label).toBe('Tweet Remix');
+    });
+    it('should require text input', () => {
+      expect(tweetRemixNodeDefinition.inputs).toHaveLength(1);
+      expect(tweetRemixNodeDefinition.inputs[0].id).toBe('text');
+      expect(tweetRemixNodeDefinition.inputs[0].required).toBe(true);
+    });
+    it('should output selected tweet text', () => {
+      expect(tweetRemixNodeDefinition.outputs).toHaveLength(1);
+      expect(tweetRemixNodeDefinition.outputs[0].id).toBe('text');
+      expect(tweetRemixNodeDefinition.outputs[0].type).toBe('text');
+    });
+    it('should reference default data', () => {
+      expect(tweetRemixNodeDefinition.defaultData).toBe(defaultTweetRemixData);
+    });
+  });
+});

package/dist/workflow-saas/src/nodes/video-input.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Video Input Node Types
+ *
+ * This node accepts multiple video URLs as input for beat-synced editing.
+ * Collects video files and calculates total duration for editing workflow.
+ */
+import type { BaseTrendNodeData } from './trend-shared';
+export interface VideoInputNodeData extends BaseTrendNodeData {
+    videoUrls: string[];
+    maxVideos: number;
+    minClipDuration: number;
+    videoFiles: string[];
+    totalDuration: number | null;
+    videoCount: number | null;
+    validationErrors: string[];
+}
+export declare const DEFAULT_VIDEO_INPUT_DATA: Partial<VideoInputNodeData>;
+export declare const videoInputNodeDefinition: {
+    category: "input";
+    defaultData: Partial<VideoInputNodeData>;
+    description: string;
+    icon: string;
+    inputs: {
+        id: string;
+        label: string;
+        multiple: boolean;
+        required: boolean;
+        type: string;
+    }[];
+    label: string;
+    outputs: ({
+        id: string;
+        label: string;
+        multiple: boolean;
+        type: string;
+    } | {
+        id: string;
+        label: string;
+        type: string;
+        multiple?: undefined;
+    })[];
+    type: string;
+};
+//# sourceMappingURL=video-input.d.ts.map

package/dist/workflow-saas/src/nodes/video-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-input.d.ts","sourceRoot":"","sources":["../../../../src/nodes/video-input.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAE3D,SAAS,EAAE,MAAM,EAAE,CAAC;IAGpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IAGxB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAG7B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,eAAO,MAAM,wBAAwB,EAAE,OAAO,CAAC,kBAAkB,CAUhE,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;CAqBpC,CAAC"}

package/dist/workflow-saas/src/nodes/video-input.js

@@ -0,0 +1,39 @@
+/**
+ * Video Input Node Types
+ *
+ * This node accepts multiple video URLs as input for beat-synced editing.
+ * Collects video files and calculates total duration for editing workflow.
+ */
+export const DEFAULT_VIDEO_INPUT_DATA = {
+    label: 'Video Input',
+    maxVideos: 10,
+    minClipDuration: 0.5,
+    status: 'idle',
+    totalDuration: null,
+    validationErrors: [],
+    videoCount: null,
+    videoFiles: [],
+    videoUrls: [],
+};
+export const videoInputNodeDefinition = {
+    category: 'input',
+    defaultData: DEFAULT_VIDEO_INPUT_DATA,
+    description: 'Accept multiple video URLs for beat-synced editing',
+    icon: 'Video',
+    inputs: [
+        {
+            id: 'videoUrls',
+            label: 'Video URLs',
+            multiple: true,
+            required: true,
+            type: 'text',
+        },
+    ],
+    label: 'Video Input',
+    outputs: [
+        { id: 'videoFiles', label: 'Video Files', multiple: true, type: 'text' },
+        { id: 'totalDuration', label: 'Total Duration (s)', type: 'number' },
+        { id: 'videoCount', label: 'Video Count', type: 'number' },
+    ],
+    type: 'videoInput',
+};

package/dist/workflow-saas/src/nodes/video-input.spec.d.ts

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

package/dist/workflow-saas/src/nodes/video-input.spec.d.ts.map

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

package/dist/workflow-saas/src/nodes/video-input.spec.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_VIDEO_INPUT_DATA,
+  videoInputNodeDefinition,
+} from './video-input';
+
+describe('video-input node', () => {
+  describe('DEFAULT_VIDEO_INPUT_DATA', () => {
+    it('should have label set to Video Input', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.label).toBe('Video Input');
+    });
+    it('should default to idle status', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.status).toBe('idle');
+    });
+    it('should default maxVideos to 10', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.maxVideos).toBe(10);
+    });
+    it('should default minClipDuration to 0.5', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.minClipDuration).toBe(0.5);
+    });
+    it('should default videoUrls and videoFiles to empty arrays', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.videoUrls).toEqual([]);
+      expect(DEFAULT_VIDEO_INPUT_DATA.videoFiles).toEqual([]);
+    });
+    it('should default validationErrors to empty array', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.validationErrors).toEqual([]);
+    });
+    it('should default totalDuration and videoCount to null', () => {
+      expect(DEFAULT_VIDEO_INPUT_DATA.totalDuration).toBeNull();
+      expect(DEFAULT_VIDEO_INPUT_DATA.videoCount).toBeNull();
+    });
+  });
+  describe('videoInputNodeDefinition', () => {
+    it('should have type videoInput', () => {
+      expect(videoInputNodeDefinition.type).toBe('videoInput');
+    });
+    it('should be in input category', () => {
+      expect(videoInputNodeDefinition.category).toBe('input');
+    });
+    it('should have label Video Input', () => {
+      expect(videoInputNodeDefinition.label).toBe('Video Input');
+    });
+    it('should have a description', () => {
+      expect(videoInputNodeDefinition.description).toBeTruthy();
+    });
+    it('should require videoUrls input as multiple', () => {
+      const input = videoInputNodeDefinition.inputs.find(
+        (i) => i.id === 'videoUrls',
+      );
+      expect(input).toBeDefined();
+      expect(input?.required).toBe(true);
+      expect(input?.multiple).toBe(true);
+    });
+    it('should have videoFiles, totalDuration, and videoCount outputs', () => {
+      const outputIds = videoInputNodeDefinition.outputs.map((o) => o.id);
+      expect(outputIds).toContain('videoFiles');
+      expect(outputIds).toContain('totalDuration');
+      expect(outputIds).toContain('videoCount');
+    });
+    it('should reference default data', () => {
+      expect(videoInputNodeDefinition.defaultData).toBe(
+        DEFAULT_VIDEO_INPUT_DATA,
+      );
+    });
+  });
+});

package/dist/workflow-saas/src/registry/connection-rules.d.ts

@@ -0,0 +1,12 @@
+import type { SaaSHandleType } from '@workflow-saas/types';
+/**
+ * Extended connection rules for SaaS handle types.
+ * Core rules are spread in, and SaaS-specific types are added.
+ */
+export declare const SAAS_CONNECTION_RULES: Record<SaaSHandleType, SaaSHandleType[]>;
+/**
+ * Validate whether a source handle type can connect to a target handle type.
+ * 'any' as a target accepts all source types.
+ */
+export declare function isValidSaaSConnection(sourceType: SaaSHandleType, targetType: SaaSHandleType): boolean;
+//# sourceMappingURL=connection-rules.d.ts.map

package/dist/workflow-saas/src/registry/connection-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-rules.d.ts","sourceRoot":"","sources":["../../../../src/registry/connection-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,cAAc,EAAE,cAAc,EAAE,CAO1E,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,cAAc,EAC1B,UAAU,EAAE,cAAc,GACzB,OAAO,CAKT"}

package/dist/workflow-saas/src/registry/connection-rules.js

@@ -0,0 +1,23 @@
+import { CONNECTION_RULES } from '@genfeedai/types/nodes';
+/**
+ * Extended connection rules for SaaS handle types.
+ * Core rules are spread in, and SaaS-specific types are added.
+ */
+export const SAAS_CONNECTION_RULES = {
+    // Core rules
+    ...CONNECTION_RULES,
+    any: ['image', 'text', 'video', 'number', 'audio', 'brand', 'object', 'any'],
+    // SaaS extensions
+    brand: ['brand'],
+    object: ['object'],
+};
+/**
+ * Validate whether a source handle type can connect to a target handle type.
+ * 'any' as a target accepts all source types.
+ */
+export function isValidSaaSConnection(sourceType, targetType) {
+    if (targetType === 'any') {
+        return true;
+    }
+    return SAAS_CONNECTION_RULES[sourceType]?.includes(targetType) ?? false;
+}

package/dist/workflow-saas/src/registry/connection-rules.spec.d.ts

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

package/dist/workflow-saas/src/registry/connection-rules.spec.d.ts.map

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

package/dist/workflow-saas/src/registry/connection-rules.spec.js

@@ -0,0 +1,29 @@
+import {
+  isValidSaaSConnection,
+  SAAS_CONNECTION_RULES,
+} from '@workflow-saas/registry/connection-rules';
+import { describe, expect, it } from 'vitest';
+
+describe('SAAS_CONNECTION_RULES', () => {
+  it('has core types', () => {
+    expect(SAAS_CONNECTION_RULES.image).toBeDefined();
+    expect(SAAS_CONNECTION_RULES.text).toBeDefined();
+  });
+  it('has saas types', () => {
+    expect(SAAS_CONNECTION_RULES.brand).toEqual(['brand']);
+    expect(SAAS_CONNECTION_RULES.object).toEqual(['object']);
+    expect(SAAS_CONNECTION_RULES.any).toContain('brand');
+  });
+});
+describe('isValidSaaSConnection', () => {
+  it('any target accepts all', () => {
+    expect(isValidSaaSConnection('image', 'any')).toBe(true);
+    expect(isValidSaaSConnection('brand', 'any')).toBe(true);
+  });
+  it('brand to brand', () =>
+    expect(isValidSaaSConnection('brand', 'brand')).toBe(true));
+  it('brand to text fails', () =>
+    expect(isValidSaaSConnection('brand', 'text')).toBe(false));
+  it('text to brand fails', () =>
+    expect(isValidSaaSConnection('text', 'brand')).toBe(false));
+});

package/dist/workflow-saas/src/registry/index.d.ts

@@ -0,0 +1,4 @@
+export * from './connection-rules';
+export * from './merged-registry';
+export * from './saas-definitions';
+//# sourceMappingURL=index.d.ts.map

package/dist/workflow-saas/src/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/registry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/workflow-saas/src/registry/index.js

@@ -0,0 +1,3 @@
+export * from './connection-rules';
+export * from './merged-registry';
+export * from './saas-definitions';

package/dist/workflow-saas/src/registry/merged-registry.d.ts

@@ -0,0 +1,83 @@
+import { NODE_DEFINITIONS as CORE_NODE_DEFINITIONS, type NodeType as CoreNodeType, type NodeCategory, type NodeDefinition } from '@genfeedai/types/nodes';
+import type { ExtendedNodeCategory } from '@workflow-saas/types';
+import { isSaaSNode, SAAS_NODE_DEFINITIONS, type SaaSNodeDefinition, type SaaSNodeType } from './saas-definitions';
+export type { CoreNodeType, NodeCategory, NodeDefinition, SaaSNodeDefinition, SaaSNodeType, };
+export { CORE_NODE_DEFINITIONS, isSaaSNode, SAAS_NODE_DEFINITIONS };
+/**
+ * Extended node type - union of core and SaaS node types
+ */
+export type ExtendedNodeType = CoreNodeType | SaaSNodeType;
+/**
+ * Extended node category - union of core and SaaS categories
+ */
+export type { ExtendedNodeCategory };
+/**
+ * Check if a node type is a core node
+ */
+export declare function isCoreNode(type: string): type is CoreNodeType;
+/**
+ * Check if a node type is valid (either core or SaaS)
+ */
+export declare function isValidNodeType(type: string): type is ExtendedNodeType;
+export declare function getNodeDefinition(type: string): NodeDefinition | SaaSNodeDefinition | undefined;
+/**
+ * Merged node definitions - combines core and SaaS nodes
+ */
+export declare const NODE_DEFINITIONS: {
+    readonly brand: SaaSNodeDefinition;
+    readonly condition: SaaSNodeDefinition;
+    readonly delay: SaaSNodeDefinition;
+    readonly engagementTrigger: SaaSNodeDefinition;
+    readonly followUser: SaaSNodeDefinition;
+    readonly keywordTrigger: SaaSNodeDefinition;
+    readonly likePost: SaaSNodeDefinition;
+    readonly musicSource: SaaSNodeDefinition;
+    readonly publish: SaaSNodeDefinition;
+    readonly personaContentPlan: SaaSNodeDefinition;
+    readonly personaPhotoSession: SaaSNodeDefinition;
+    readonly personaVideoContent: SaaSNodeDefinition;
+    readonly postReply: SaaSNodeDefinition;
+    readonly sendDm: SaaSNodeDefinition;
+    readonly soundOverlay: SaaSNodeDefinition;
+    readonly brandContext: SaaSNodeDefinition;
+    readonly brandAsset: SaaSNodeDefinition;
+    readonly patternContext: SaaSNodeDefinition;
+    readonly imageInput: NodeDefinition;
+    readonly audioInput: NodeDefinition;
+    readonly videoInput: NodeDefinition;
+    readonly prompt: NodeDefinition;
+    readonly promptConstructor: NodeDefinition;
+    readonly imageGen: NodeDefinition;
+    readonly videoGen: NodeDefinition;
+    readonly llm: NodeDefinition;
+    readonly lipSync: NodeDefinition;
+    readonly voiceChange: NodeDefinition;
+    readonly textToSpeech: NodeDefinition;
+    readonly transcribe: NodeDefinition;
+    readonly motionControl: NodeDefinition;
+    readonly resize: NodeDefinition;
+    readonly animation: NodeDefinition;
+    readonly videoStitch: NodeDefinition;
+    readonly videoTrim: NodeDefinition;
+    readonly videoFrameExtract: NodeDefinition;
+    readonly reframe: NodeDefinition;
+    readonly upscale: NodeDefinition;
+    readonly imageGridSplit: NodeDefinition;
+    readonly annotation: NodeDefinition;
+    readonly subtitle: NodeDefinition;
+    readonly outputGallery: NodeDefinition;
+    readonly imageCompare: NodeDefinition;
+    readonly download: NodeDefinition;
+    readonly workflowInput: NodeDefinition;
+    readonly workflowOutput: NodeDefinition;
+    readonly workflowRef: NodeDefinition;
+};
+/**
+ * Get all node types grouped by category
+ */
+export declare function getNodesByExtendedCategory(): Record<ExtendedNodeCategory, (NodeDefinition | SaaSNodeDefinition)[]>;
+/**
+ * Get all extended node types
+ */
+export declare function getAllNodeTypes(): ExtendedNodeType[];
+//# sourceMappingURL=merged-registry.d.ts.map

package/dist/workflow-saas/src/registry/merged-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merged-registry.d.ts","sourceRoot":"","sources":["../../../../src/registry/merged-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,IAAI,qBAAqB,EACzC,KAAK,QAAQ,IAAI,YAAY,EAC7B,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EACL,UAAU,EACV,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,YAAY,GACb,CAAC;AACF,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,qBAAqB,EAAE,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,YAAY,CAAC;AAE3D;;GAEG;AACH,YAAY,EAAE,oBAAoB,EAAE,CAAC;AAErC;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,YAAY,CAE7D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,gBAAgB,CAEtE;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GACX,cAAc,GAAG,kBAAkB,GAAG,SAAS,CAQjD;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC;AAeX;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAClD,oBAAoB,EACpB,CAAC,cAAc,GAAG,kBAAkB,CAAC,EAAE,CACxC,CAiBA;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,gBAAgB,EAAE,CAKpD"}

package/dist/workflow-saas/src/registry/merged-registry.js

@@ -0,0 +1,65 @@
+import { NODE_DEFINITIONS as CORE_NODE_DEFINITIONS, } from '@genfeedai/types/nodes';
+import { isSaaSNode, SAAS_NODE_DEFINITIONS, } from './saas-definitions';
+export { CORE_NODE_DEFINITIONS, isSaaSNode, SAAS_NODE_DEFINITIONS };
+/**
+ * Check if a node type is a core node
+ */
+export function isCoreNode(type) {
+    return type in CORE_NODE_DEFINITIONS;
+}
+/**
+ * Check if a node type is valid (either core or SaaS)
+ */
+export function isValidNodeType(type) {
+    return isCoreNode(type) || isSaaSNode(type);
+}
+export function getNodeDefinition(type) {
+    if (isCoreNode(type)) {
+        return CORE_NODE_DEFINITIONS[type];
+    }
+    if (isSaaSNode(type)) {
+        return SAAS_NODE_DEFINITIONS[type];
+    }
+    return undefined;
+}
+/**
+ * Merged node definitions - combines core and SaaS nodes
+ */
+export const NODE_DEFINITIONS = {
+    ...CORE_NODE_DEFINITIONS,
+    ...SAAS_NODE_DEFINITIONS,
+};
+/** Valid extended categories */
+const EXTENDED_CATEGORIES = [
+    'input',
+    'ai',
+    'processing',
+    'output',
+    'distribution',
+    'composition',
+    'saas',
+    'automation',
+    'repurposing',
+];
+/**
+ * Get all node types grouped by category
+ */
+export function getNodesByExtendedCategory() {
+    const categories = Object.fromEntries(EXTENDED_CATEGORIES.map((cat) => [cat, []]));
+    for (const def of Object.values(CORE_NODE_DEFINITIONS)) {
+        categories[def.category]?.push(def);
+    }
+    for (const def of Object.values(SAAS_NODE_DEFINITIONS)) {
+        categories[def.category]?.push(def);
+    }
+    return categories;
+}
+/**
+ * Get all extended node types
+ */
+export function getAllNodeTypes() {
+    return [
+        ...Object.keys(CORE_NODE_DEFINITIONS),
+        ...Object.keys(SAAS_NODE_DEFINITIONS),
+    ];
+}

package/dist/workflow-saas/src/registry/merged-registry.spec.d.ts

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

package/dist/workflow-saas/src/registry/merged-registry.spec.d.ts.map

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

package/dist/workflow-saas/src/registry/merged-registry.spec.js

@@ -0,0 +1,41 @@
+import {
+  getAllNodeTypes,
+  getNodeDefinition,
+  getNodesByExtendedCategory,
+  isCoreNode,
+  isValidNodeType,
+  NODE_DEFINITIONS,
+} from '@workflow-saas/registry/merged-registry';
+import { describe, expect, it } from 'vitest';
+
+describe('isCoreNode', () => {
+  it('false for saas nodes', () => {
+    expect(isCoreNode('brand')).toBe(false);
+  });
+});
+describe('isValidNodeType', () => {
+  it('true for saas', () => expect(isValidNodeType('brand')).toBe(true));
+  it('false for unknown', () => expect(isValidNodeType('xxx')).toBe(false));
+});
+describe('getNodeDefinition', () => {
+  it('saas node', () => {
+    expect(getNodeDefinition('brand')?.label).toBe('Brand');
+  });
+  it('unknown', () => expect(getNodeDefinition('xxx')).toBeUndefined());
+});
+describe('NODE_DEFINITIONS', () => {
+  it('has brand', () => expect(NODE_DEFINITIONS.brand).toBeDefined());
+});
+describe('getNodesByExtendedCategory', () => {
+  it('returns categories', () => {
+    const cats = getNodesByExtendedCategory();
+    expect(Object.values(cats).flat().length).toBeGreaterThan(0);
+  });
+});
+describe('getAllNodeTypes', () => {
+  it('includes saas types', () => {
+    const types = getAllNodeTypes();
+    expect(types).toContain('brand');
+    expect(types.length).toBeGreaterThan(5);
+  });
+});

package/dist/workflow-saas/src/registry/saas-definitions.d.ts

@@ -0,0 +1,39 @@
+import type { ExtendedNodeCategory, SaaSHandleDefinition } from '@workflow-saas/types';
+/**
+ * SaaS-specific node types
+ */
+export type SaaSNodeType = 'brandContext' | 'brandAsset' | 'brand' | 'condition' | 'delay' | 'engagementTrigger' | 'followUser' | 'keywordTrigger' | 'likePost' | 'musicSource' | 'patternContext' | 'personaContentPlan' | 'personaPhotoSession' | 'personaVideoContent' | 'postReply' | 'publish' | 'sendDm' | 'soundOverlay';
+/**
+ * SaaS node category (extends core categories)
+ */
+export type SaaSNodeCategory = Extract<ExtendedNodeCategory, 'saas' | 'input' | 'output' | 'automation' | 'processing'>;
+/**
+ * Extended node definition for SaaS nodes
+ */
+export interface SaaSNodeDefinition {
+    type: SaaSNodeType;
+    label: string;
+    description: string;
+    category: SaaSNodeCategory;
+    icon: string;
+    inputs: SaaSHandleDefinition[];
+    outputs: SaaSHandleDefinition[];
+    defaultData: Record<string, unknown>;
+}
+/**
+ * SaaS-specific node definitions
+ *
+ * These nodes are only available in the SaaS platform
+ * and extend the core workflow functionality with
+ * multi-tenant features like brand context and assets.
+ */
+export declare const SAAS_NODE_DEFINITIONS: Record<SaaSNodeType, SaaSNodeDefinition>;
+/**
+ * Get all SaaS node types
+ */
+export declare function getSaaSNodeTypes(): SaaSNodeType[];
+/**
+ * Check if a node type is a SaaS node
+ */
+export declare function isSaaSNode(type: string): type is SaaSNodeType;
+//# sourceMappingURL=saas-definitions.d.ts.map

package/dist/workflow-saas/src/registry/saas-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saas-definitions.d.ts","sourceRoot":"","sources":["../../../../src/registry/saas-definitions.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAE9B;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,cAAc,GACd,YAAY,GACZ,OAAO,GACP,WAAW,GACX,OAAO,GACP,mBAAmB,GACnB,YAAY,GACZ,gBAAgB,GAChB,UAAU,GACV,aAAa,GACb,gBAAgB,GAChB,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,WAAW,GACX,SAAS,GACT,QAAQ,GACR,cAAc,CAAC;AAEnB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CACpC,oBAAoB,EACpB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,YAAY,CAC1D,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,YAAY,EAAE,kBAAkB,CAuR1E,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,YAAY,EAAE,CAEjD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,YAAY,CAE7D"}