@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/types.d.ts

@@ -0,0 +1,56 @@
+export type { ExecutableEdge, ExecutableNode, ExecutableWorkflow, ExecutionOptions, ExecutionProgressEvent, ExecutionStatus, NodeExecutionStatus, NodeStatusChangeEvent, RetryConfig, ValidationError, ValidationResult, ValidationWarning, WorkflowLifecycle, } from '@workflow-engine/workflows-contracts-shim';
+export { DEFAULT_RETRY_CONFIG } from '@workflow-engine/workflows-contracts-shim';
+export interface NodeExecutionResult {
+    nodeId: string;
+    status: import('@workflow-engine/workflows-contracts-shim').NodeExecutionStatus;
+    output?: unknown;
+    error?: string;
+    startedAt: Date;
+    completedAt?: Date;
+    retryCount: number;
+    creditsUsed: number;
+}
+export interface ExecutionRunResult {
+    runId: string;
+    workflowId: string;
+    status: import('@workflow-engine/workflows-contracts-shim').ExecutionStatus;
+    nodeResults: Map<string, NodeExecutionResult>;
+    totalCreditsUsed: number;
+    startedAt: Date;
+    completedAt?: Date;
+    error?: string;
+}
+export interface ExecutionRun {
+    runId: string;
+    status: import('@workflow-engine/workflows-contracts-shim').ExecutionStatus;
+    executedNodeIds: string[];
+    failedNodeId?: string;
+    error?: string;
+    creditsUsed: number;
+    startedAt: Date;
+    completedAt?: Date;
+    nodeResults: Array<{
+        nodeId: string;
+        status: import('@workflow-engine/workflows-contracts-shim').NodeExecutionStatus;
+        output?: unknown;
+        error?: string;
+        startedAt: Date;
+        completedAt?: Date;
+        retryCount: number;
+        creditsUsed: number;
+    }>;
+}
+export interface CreditCostConfig {
+    [nodeType: string]: number;
+}
+export interface CreditEstimate {
+    totalCredits: number;
+    breakdown: Array<{
+        nodeId: string;
+        nodeType: string;
+        credits: number;
+    }>;
+    hasInsufficientCredits: boolean;
+    availableCredits: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/workflow-engine/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAEjF,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,2CAA2C,EAAE,mBAAmB,CAAC;IAChF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,2CAA2C,EAAE,eAAe,CAAC;IAC5E,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC9C,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,2CAA2C,EAAE,eAAe,CAAC;IAC5E,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,WAAW,EAAE,KAAK,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,OAAO,2CAA2C,EAAE,mBAAmB,CAAC;QAChF,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,IAAI,CAAC;QAChB,WAAW,CAAC,EAAE,IAAI,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,KAAK,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC,gBAAgB,EAAE,MAAM,CAAC;CAC1B"}

package/dist/workflow-engine/src/types.js

@@ -0,0 +1 @@
+export { DEFAULT_RETRY_CONFIG } from '@workflow-engine/workflows-contracts-shim';

package/dist/workflow-engine/src/utils/credit-calculator.d.ts

@@ -0,0 +1,14 @@
+import type { CreditCostConfig, CreditEstimate, ExecutableNode } from '@workflow-engine/types';
+export declare const DEFAULT_CREDIT_COSTS: CreditCostConfig;
+export declare function calculateCreditEstimate(nodes: ExecutableNode[], availableCredits: number, customCosts?: Partial<CreditCostConfig>): CreditEstimate;
+export declare function getNodeCreditCost(nodeType: string, customCosts?: Partial<CreditCostConfig>): number;
+export declare function hasInsufficientCredits(nodes: ExecutableNode[], availableCredits: number, customCosts?: Partial<CreditCostConfig>): boolean;
+export declare function filterByBudget(nodes: ExecutableNode[], edges: Array<{
+    source: string;
+    target: string;
+}>, availableCredits: number, customCosts?: Partial<CreditCostConfig>): ExecutableNode[];
+export declare function groupCostsByCategory(nodes: ExecutableNode[], customCosts?: Partial<CreditCostConfig>): Record<string, {
+    nodes: string[];
+    totalCredits: number;
+}>;
+//# sourceMappingURL=credit-calculator.d.ts.map

package/dist/workflow-engine/src/utils/credit-calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credit-calculator.d.ts","sourceRoot":"","sources":["../../../../src/utils/credit-calculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,cAAc,EACf,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,oBAAoB,EAAE,gBAwBlC,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,cAAc,EAAE,EACvB,gBAAgB,EAAE,MAAM,EACxB,WAAW,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC1C,cAAc,CAsBhB;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,WAAW,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC1C,MAAM,CAGR;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EAAE,EACvB,gBAAgB,EAAE,MAAM,EACxB,WAAW,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC1C,OAAO,CAOT;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,cAAc,EAAE,EACvB,KAAK,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EAChD,gBAAgB,EAAE,MAAM,EACxB,WAAW,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC1C,cAAc,EAAE,CA0DlB;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,cAAc,EAAE,EACvB,WAAW,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC1C,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAe3D"}

package/dist/workflow-engine/src/utils/credit-calculator.js

@@ -0,0 +1,138 @@
+export const DEFAULT_CREDIT_COSTS = {
+    brand: 0,
+    brandAsset: 0,
+    brandContext: 0,
+    caption: 1,
+    clip: 2,
+    condition: 0,
+    delay: 0,
+    generateArticle: 3,
+    generateImage: 5,
+    generateMusic: 8,
+    generateVideo: 10,
+    imageGen: 5,
+    loop: 0,
+    publish: 0,
+    resize: 1,
+    rssInput: 0,
+    socialPublish: 0,
+    transform: 1,
+    tweetInput: 0,
+    tweetRemix: 1,
+    upscale: 2,
+    videoGen: 10,
+    webhook: 0,
+};
+export function calculateCreditEstimate(nodes, availableCredits, customCosts = {}) {
+    const costs = { ...DEFAULT_CREDIT_COSTS, ...customCosts };
+    const breakdown = [];
+    let totalCredits = 0;
+    for (const node of nodes) {
+        const credits = costs[node.type] ?? 0;
+        breakdown.push({
+            credits,
+            nodeId: node.id,
+            nodeType: node.type,
+        });
+        totalCredits += credits;
+    }
+    return {
+        availableCredits,
+        breakdown,
+        hasInsufficientCredits: totalCredits > availableCredits,
+        totalCredits,
+    };
+}
+export function getNodeCreditCost(nodeType, customCosts = {}) {
+    const costs = { ...DEFAULT_CREDIT_COSTS, ...customCosts };
+    return costs[nodeType] ?? 0;
+}
+export function hasInsufficientCredits(nodes, availableCredits, customCosts = {}) {
+    const estimate = calculateCreditEstimate(nodes, availableCredits, customCosts);
+    return estimate.hasInsufficientCredits;
+}
+export function filterByBudget(nodes, edges, availableCredits, customCosts = {}) {
+    const costs = { ...DEFAULT_CREDIT_COSTS, ...customCosts };
+    const inDegree = new Map();
+    const adjList = new Map();
+    for (const node of nodes) {
+        inDegree.set(node.id, 0);
+        adjList.set(node.id, []);
+    }
+    for (const edge of edges) {
+        if (inDegree.has(edge.target)) {
+            inDegree.set(edge.target, (inDegree.get(edge.target) ?? 0) + 1);
+        }
+        if (adjList.has(edge.source)) {
+            adjList.get(edge.source)?.push(edge.target);
+        }
+    }
+    const queue = [];
+    for (const [nodeId, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(nodeId);
+        }
+    }
+    const result = [];
+    let remainingCredits = availableCredits;
+    const included = new Set();
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (!currentId) {
+            continue;
+        }
+        const node = nodes.find((n) => n.id === currentId);
+        if (!node) {
+            continue;
+        }
+        const cost = costs[node.type] ?? 0;
+        if (cost <= remainingCredits) {
+            result.push(node);
+            included.add(node.id);
+            remainingCredits -= cost;
+            for (const neighbor of adjList.get(currentId) ?? []) {
+                const newDegree = (inDegree.get(neighbor) ?? 0) - 1;
+                inDegree.set(neighbor, newDegree);
+                if (newDegree === 0) {
+                    queue.push(neighbor);
+                }
+            }
+        }
+    }
+    return result;
+}
+export function groupCostsByCategory(nodes, customCosts = {}) {
+    const costs = { ...DEFAULT_CREDIT_COSTS, ...customCosts };
+    const categories = {};
+    for (const node of nodes) {
+        const category = getNodeCategory(node.type);
+        if (!categories[category]) {
+            categories[category] = { nodes: [], totalCredits: 0 };
+        }
+        categories[category].nodes.push(node.id);
+        categories[category].totalCredits += costs[node.type] ?? 0;
+    }
+    return categories;
+}
+const NODE_CATEGORY_MAP = {
+    brand: 'input',
+    brandAsset: 'input',
+    brandContext: 'input',
+    condition: 'control',
+    delay: 'control',
+    generateArticle: 'ai',
+    generateImage: 'ai',
+    generateMusic: 'ai',
+    generateVideo: 'ai',
+    imageGen: 'ai',
+    loop: 'control',
+    publish: 'output',
+    rssInput: 'input',
+    socialPublish: 'output',
+    tweetInput: 'input',
+    videoGen: 'ai',
+    webhook: 'output',
+};
+function getNodeCategory(nodeType) {
+    return NODE_CATEGORY_MAP[nodeType] ?? 'processing';
+}

package/dist/workflow-engine/src/utils/credit-calculator.spec.d.ts

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

package/dist/workflow-engine/src/utils/credit-calculator.spec.d.ts.map

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

package/dist/workflow-engine/src/utils/credit-calculator.spec.js

@@ -0,0 +1,322 @@
+import {
+  calculateCreditEstimate,
+  DEFAULT_CREDIT_COSTS,
+  filterByBudget,
+  getNodeCreditCost,
+  groupCostsByCategory,
+  hasInsufficientCredits,
+} from '@workflow-engine/utils/credit-calculator';
+import { describe, expect, it } from 'vitest';
+
+function makeNode(id, type, overrides = {}) {
+  return {
+    config: {},
+    id,
+    inputs: [],
+    label: id,
+    type,
+    ...overrides,
+  };
+}
+describe('calculateCreditEstimate', () => {
+  it('should return zero credits for empty node list', () => {
+    const result = calculateCreditEstimate([], 100);
+    expect(result.totalCredits).toBe(0);
+    expect(result.breakdown).toHaveLength(0);
+    expect(result.hasInsufficientCredits).toBe(false);
+    expect(result.availableCredits).toBe(100);
+  });
+  it('should calculate cost for a single node using default costs', () => {
+    const result = calculateCreditEstimate(
+      [makeNode('n1', 'generateImage')],
+      100,
+    );
+    expect(result.totalCredits).toBe(5);
+    expect(result.breakdown).toHaveLength(1);
+    expect(result.breakdown[0]).toEqual({
+      credits: 5,
+      nodeId: 'n1',
+      nodeType: 'generateImage',
+    });
+  });
+  it('should sum costs for multiple nodes', () => {
+    const result = calculateCreditEstimate(
+      [
+        makeNode('n1', 'generateImage'),
+        makeNode('n2', 'generateVideo'),
+        makeNode('n3', 'upscale'),
+      ],
+      100,
+    );
+    // generateImage=5, generateVideo=10, upscale=2
+    expect(result.totalCredits).toBe(17);
+    expect(result.breakdown).toHaveLength(3);
+  });
+  it('should use custom costs when provided', () => {
+    const result = calculateCreditEstimate(
+      [makeNode('n1', 'generateImage')],
+      100,
+      { generateImage: 20 },
+    );
+    expect(result.totalCredits).toBe(20);
+    expect(result.breakdown[0].credits).toBe(20);
+  });
+  it('should return 0 credits for unknown node types', () => {
+    const result = calculateCreditEstimate(
+      [makeNode('n1', 'unknownType')],
+      100,
+    );
+    expect(result.totalCredits).toBe(0);
+    expect(result.breakdown[0].credits).toBe(0);
+  });
+  it('should flag insufficient credits when total exceeds available', () => {
+    const result = calculateCreditEstimate(
+      [makeNode('n1', 'generateVideo')],
+      5,
+    );
+    // generateVideo = 10, available = 5
+    expect(result.hasInsufficientCredits).toBe(true);
+  });
+  it('should not flag insufficient credits when total equals available', () => {
+    const result = calculateCreditEstimate(
+      [makeNode('n1', 'generateVideo')],
+      10,
+    );
+    // generateVideo = 10, available = 10
+    expect(result.hasInsufficientCredits).toBe(false);
+  });
+  it('should not flag insufficient credits when under budget', () => {
+    const result = calculateCreditEstimate([makeNode('n1', 'caption')], 100);
+    expect(result.hasInsufficientCredits).toBe(false);
+  });
+  it('should correctly report available credits', () => {
+    const result = calculateCreditEstimate(
+      [makeNode('n1', 'generateImage')],
+      42,
+    );
+    expect(result.availableCredits).toBe(42);
+  });
+});
+describe('getNodeCreditCost', () => {
+  it('should return default cost for known node types', () => {
+    expect(getNodeCreditCost('generateImage')).toBe(5);
+    expect(getNodeCreditCost('generateVideo')).toBe(10);
+    expect(getNodeCreditCost('upscale')).toBe(2);
+    expect(getNodeCreditCost('caption')).toBe(1);
+    expect(getNodeCreditCost('generateMusic')).toBe(8);
+  });
+  it('should return 0 for unknown node types', () => {
+    expect(getNodeCreditCost('unknownType')).toBe(0);
+    expect(getNodeCreditCost('')).toBe(0);
+  });
+  it('should return 0 for free node types', () => {
+    expect(getNodeCreditCost('webhook')).toBe(0);
+    expect(getNodeCreditCost('delay')).toBe(0);
+    expect(getNodeCreditCost('condition')).toBe(0);
+    expect(getNodeCreditCost('publish')).toBe(0);
+    expect(getNodeCreditCost('rssInput')).toBe(0);
+  });
+  it('should use custom cost when provided', () => {
+    expect(getNodeCreditCost('generateImage', { generateImage: 99 })).toBe(99);
+  });
+  it('should fall back to default if custom cost does not cover the type', () => {
+    expect(getNodeCreditCost('generateImage', { upscale: 99 })).toBe(5);
+  });
+});
+describe('hasInsufficientCredits', () => {
+  it('should return true when cost exceeds available credits', () => {
+    const result = hasInsufficientCredits(
+      [makeNode('n1', 'generateVideo'), makeNode('n2', 'generateImage')],
+      10,
+    );
+    // 10 + 5 = 15 > 10
+    expect(result).toBe(true);
+  });
+  it('should return false when cost is within budget', () => {
+    const result = hasInsufficientCredits([makeNode('n1', 'caption')], 100);
+    expect(result).toBe(false);
+  });
+  it('should return false when cost equals available credits', () => {
+    const result = hasInsufficientCredits(
+      [makeNode('n1', 'generateVideo')],
+      10,
+    );
+    expect(result).toBe(false);
+  });
+  it('should return false for empty nodes', () => {
+    const result = hasInsufficientCredits([], 0);
+    expect(result).toBe(false);
+  });
+  it('should use custom costs when provided', () => {
+    const result = hasInsufficientCredits(
+      [makeNode('n1', 'generateImage')],
+      3,
+      { generateImage: 100 },
+    );
+    expect(result).toBe(true);
+  });
+});
+describe('filterByBudget', () => {
+  it('should include all nodes when budget is sufficient', () => {
+    const nodes = [makeNode('n1', 'caption'), makeNode('n2', 'upscale')];
+    const edges = [{ source: 'n1', target: 'n2' }];
+    const result = filterByBudget(nodes, edges, 100);
+    expect(result).toHaveLength(2);
+    expect(result.map((n) => n.id)).toEqual(['n1', 'n2']);
+  });
+  it('should exclude nodes when budget is exceeded', () => {
+    const nodes = [
+      makeNode('n1', 'generateVideo'),
+      makeNode('n2', 'generateImage'),
+    ];
+    const edges = [{ source: 'n1', target: 'n2' }];
+    // generateVideo=10, only 10 credits => n1 fits but n2 (5) would make 15
+    const result = filterByBudget(nodes, edges, 10);
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('n1');
+  });
+  it('should return empty array when no nodes fit the budget', () => {
+    const nodes = [makeNode('n1', 'generateVideo')];
+    const result = filterByBudget(nodes, [], 5);
+    expect(result).toHaveLength(0);
+  });
+  it('should process nodes in topological order', () => {
+    // n1->n2->n3, each costs 5
+    const nodes = [
+      makeNode('n1', 'generateImage'),
+      makeNode('n2', 'generateImage'),
+      makeNode('n3', 'generateImage'),
+    ];
+    const edges = [
+      { source: 'n1', target: 'n2' },
+      { source: 'n2', target: 'n3' },
+    ];
+    // Budget allows only 2 nodes (5+5=10)
+    const result = filterByBudget(nodes, edges, 10);
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe('n1');
+    expect(result[1].id).toBe('n2');
+  });
+  it('should handle nodes with no edges', () => {
+    const nodes = [makeNode('n1', 'caption'), makeNode('n2', 'caption')];
+    const result = filterByBudget(nodes, [], 100);
+    expect(result).toHaveLength(2);
+  });
+  it('should use custom costs', () => {
+    const nodes = [makeNode('n1', 'caption')];
+    // Default caption = 1, custom = 200
+    const result = filterByBudget(nodes, [], 50, { caption: 200 });
+    expect(result).toHaveLength(0);
+  });
+});
+describe('groupCostsByCategory', () => {
+  it('should group AI nodes together', () => {
+    const nodes = [
+      makeNode('n1', 'generateImage'),
+      makeNode('n2', 'generateVideo'),
+    ];
+    const result = groupCostsByCategory(nodes);
+    expect(result.ai).toBeDefined();
+    expect(result.ai.nodes).toContain('n1');
+    expect(result.ai.nodes).toContain('n2');
+    expect(result.ai.totalCredits).toBe(15); // 5 + 10
+  });
+  it('should group input nodes together', () => {
+    const nodes = [
+      makeNode('n1', 'rssInput'),
+      makeNode('n2', 'tweetInput'),
+      makeNode('n3', 'brand'),
+    ];
+    const result = groupCostsByCategory(nodes);
+    expect(result.input).toBeDefined();
+    expect(result.input.nodes).toHaveLength(3);
+    expect(result.input.totalCredits).toBe(0); // all free
+  });
+  it('should group output nodes together', () => {
+    const nodes = [
+      makeNode('n1', 'publish'),
+      makeNode('n2', 'socialPublish'),
+      makeNode('n3', 'webhook'),
+    ];
+    const result = groupCostsByCategory(nodes);
+    expect(result.output).toBeDefined();
+    expect(result.output.nodes).toHaveLength(3);
+    expect(result.output.totalCredits).toBe(0);
+  });
+  it('should group control nodes together', () => {
+    const nodes = [
+      makeNode('n1', 'condition'),
+      makeNode('n2', 'delay'),
+      makeNode('n3', 'loop'),
+    ];
+    const result = groupCostsByCategory(nodes);
+    expect(result.control).toBeDefined();
+    expect(result.control.nodes).toHaveLength(3);
+    expect(result.control.totalCredits).toBe(0);
+  });
+  it('should fall back to processing category for unknown types', () => {
+    const nodes = [makeNode('n1', 'resize'), makeNode('n2', 'transform')];
+    const result = groupCostsByCategory(nodes);
+    expect(result.processing).toBeDefined();
+    expect(result.processing.nodes).toHaveLength(2);
+    // resize=1, transform=1
+    expect(result.processing.totalCredits).toBe(2);
+  });
+  it('should handle empty node list', () => {
+    const result = groupCostsByCategory([]);
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+  it('should produce multiple categories for mixed node types', () => {
+    const nodes = [
+      makeNode('n1', 'generateImage'),
+      makeNode('n2', 'rssInput'),
+      makeNode('n3', 'publish'),
+      makeNode('n4', 'condition'),
+      makeNode('n5', 'resize'),
+    ];
+    const result = groupCostsByCategory(nodes);
+    expect(Object.keys(result).sort()).toEqual([
+      'ai',
+      'control',
+      'input',
+      'output',
+      'processing',
+    ]);
+  });
+  it('should use custom costs when provided', () => {
+    const nodes = [makeNode('n1', 'generateImage')];
+    const result = groupCostsByCategory(nodes, { generateImage: 50 });
+    expect(result.ai.totalCredits).toBe(50);
+  });
+});
+describe('DEFAULT_CREDIT_COSTS', () => {
+  it('should have expected values for AI node types', () => {
+    expect(DEFAULT_CREDIT_COSTS.generateImage).toBe(5);
+    expect(DEFAULT_CREDIT_COSTS.generateVideo).toBe(10);
+    expect(DEFAULT_CREDIT_COSTS.generateArticle).toBe(3);
+    expect(DEFAULT_CREDIT_COSTS.generateMusic).toBe(8);
+    expect(DEFAULT_CREDIT_COSTS.imageGen).toBe(5);
+    expect(DEFAULT_CREDIT_COSTS.videoGen).toBe(10);
+  });
+  it('should have zero cost for free node types', () => {
+    expect(DEFAULT_CREDIT_COSTS.brand).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.brandAsset).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.brandContext).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.condition).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.delay).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.loop).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.publish).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.rssInput).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.socialPublish).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.tweetInput).toBe(0);
+    expect(DEFAULT_CREDIT_COSTS.webhook).toBe(0);
+  });
+  it('should have expected values for processing node types', () => {
+    expect(DEFAULT_CREDIT_COSTS.caption).toBe(1);
+    expect(DEFAULT_CREDIT_COSTS.clip).toBe(2);
+    expect(DEFAULT_CREDIT_COSTS.resize).toBe(1);
+    expect(DEFAULT_CREDIT_COSTS.transform).toBe(1);
+    expect(DEFAULT_CREDIT_COSTS.tweetRemix).toBe(1);
+    expect(DEFAULT_CREDIT_COSTS.upscale).toBe(2);
+  });
+});

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

@@ -0,0 +1,2 @@
+export * from '@workflow-engine/utils/credit-calculator';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC"}

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

@@ -0,0 +1 @@
+export * from '@workflow-engine/utils/credit-calculator';

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

@@ -0,0 +1,2 @@
+export * from '@workflow-engine/validation/workflow-validator';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC"}

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

@@ -0,0 +1 @@
+export * from '@workflow-engine/validation/workflow-validator';

package/dist/workflow-engine/src/validation/workflow-validator.d.ts

@@ -0,0 +1,17 @@
+import type { ExecutableNode, ExecutableWorkflow, ValidationError, ValidationResult } from '@workflow-engine/types';
+export interface ValidationOptions {
+    validateConfigs?: boolean;
+    checkDisconnected?: boolean;
+    requiredNodeTypes?: string[];
+    maxNodes?: number;
+}
+export declare function validateWorkflow(workflow: ExecutableWorkflow, options?: ValidationOptions): ValidationResult;
+export declare function validateNodeConfig(node: ExecutableNode, schema: Record<string, {
+    required?: boolean;
+    type?: string;
+}>): ValidationError[];
+export declare function hasInputNodes(workflow: ExecutableWorkflow): boolean;
+export declare function hasOutputNodes(workflow: ExecutableWorkflow): boolean;
+export declare function getInputNodes(workflow: ExecutableWorkflow): ExecutableNode[];
+export declare function getOutputNodes(workflow: ExecutableWorkflow): ExecutableNode[];
+//# sourceMappingURL=workflow-validator.d.ts.map

package/dist/workflow-engine/src/validation/workflow-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-validator.d.ts","sourceRoot":"","sources":["../../../../src/validation/workflow-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,iBAAiB;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAQD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CAmIlB;AAgED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAC5D,eAAe,EAAE,CAgCnB;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAGnE;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAGpE;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,cAAc,EAAE,CAG5E;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,cAAc,EAAE,CAG7E"}